eight: normal; }
svg .domain, svg .tick { color: #888; }
svg text { font-family: 'IBM Plex Serif', serif; }
figcaption { font-size: 80%; color: #666; padding-top: 1ex; }
svg.clickable circle:hover { stroke: #00a; stroke-width: 10; cursor: pointer; }

/* Flag list / configuration */

#about { margin: 3em 0; }
#about th { font-weight: bold; text-align: left; padding-right: 1em; }

#flag-list { position: relative; }
#flag-list kbd:not(:last-child):after { content: ", "; }
#flag-list a { float: right; margin: 0 .5em; }
#flag-list a:before { content: "("; }
#flag-list a:after { content: ")"; }
#flag-list #changed-flags { display: none; }
#flag-list #all-flags { display: block; }
#flag-list.changed-flags #changed-flags { display: block; }
#flag-list.changed-flags #all-flags { display: none; }

/* Result color pallette */
:root {
    --accent-text: #4a4a4a;
    --accent-title: #888;
    --accent-board: #ddd;
    --result-green: #87fc70;
    --result-light-green: #e0f8d8;
    --result-light-orange: #ff9500;
    --result-orange: #ff9500;
    --result-red-orange: #ff5e3a;
    --result-red: #ff0000;
    --result-yellow: #ffdb4c;
    --result-timeout: #8e8e93;
    --result-error: #4a4a4a;
    --accent-blue: #0000aa;
}

/* Result table filters */
label.imp-start {accent-color: var(--result-green);}
label.apx-start {accent-color: var(--result-orange);}
label.uni-start {accent-color: var(--result-red-orange);}
label.ex-start {accent-color: var(--result-light-green);}
label.eq-start {accent-color: var(--result-green);}
label.lt-start {accent-color: var(--result-yellow);}
label.gt-target {accent-color: var(--result-green);}
label.gt-start {accent-color: var(--result-green);}
label.eq-target {accent-color: var(--result-green);}
label.lt-target {accent-color: var(--result-orange);}
label.crash {accent-color: var(--result-red);}
label.error {accent-color: var(--result-error);}
label.timeout {accent-color: var(--result-timeout);}
#filters label {margin: 0; display: inline-block; padding: .4ex; color: var(--accent-text);}
#filters summary {accent-color: var(--accent-blue);}
#filters .sub-filter {column-width: 11.5rem;}

/* Compare Reports */
.diff-time-red {color: red;}
.diff-time-green {color: green;}
.diff-time-gray {color: gray;}
.diff-status {color: #0000aa;}
.report-details {border: 1px solid var(--accent-board); padding: 1ex; margin: 0 0 1em 0;}
.report-details h2 {font-size: 16px;}
.report-details h3 {font-size: 14px;}
.report-details h2, h3 {color: var(--accent-title); line-height: 1.4;}
.report-details form { display: inline;}
.report-details > details summary h2 {padding-right: 1em;}
.report-details > details > div > h3 {margin: 0; display: inline; padding-


ckground-image: url(../images/default/box/l-blue.gif);
}

.x-box-blue .x-box-mr {
	background-image: url(../images/default/box/r-blue.gif);
}
/*!
 * Ext JS Library 3.2.1
 * Copyright(c) 2006-2010 Ext JS, Inc.
 * licensing@extjs.com
 * http://www.extjs.com/license
 */
body {
	background-color:#16181a;
	color:#fcfcfc;
}

.ext-el-mask {
    background-color: #ccc;
}

.ext-el-mask-msg {
    border-color:#223;
    background-color:#3f4757;
    background-image:url(../images/access/box/tb-blue.gif);
}
.ext-el-mask-msg div {
    background-color: #232d38;
    border-color:#556;
    color:#fff;
    font:normal 14px tahoma, arial, helvetica, sans-serif;
}

.x-mask-loading div {
    background-color:#232d38;
    background-image:url(../images/access/grid/loading.gif);
}

.x-item-disabled {
    color: #ddd;
}

.x-item-disabled * {
    color: #ddd !important;
}

.x-splitbar-proxy {
    background-color: #aaa;
}

.x-color-palette a {
    border-color:#fff;
}

.x-color-palette a:hover, .x-color-palette a.x-color-palette-sel {
    border-color:#8bb8f3;
    background-color: #deecfd;
}

.x-color-palette em {
    border-color:#aca899;
}

.x-ie-shadow {
    background-color:#777;
}

.x-shadow .xsmc {
    background-image: url(../images/default/shadow-c.png);
}

.x-shadow .xsml, .x-shadow .xsmr {
    background-image: url(../images/default/shadow-lr.png);
}

.x-shadow .xstl, .x-shadow .xstc,  .x-shadow .xstr, .x-shadow .xsbl, .x-shadow .xsbc, .x-shadow .xsbr{
    background-image: url(../images/default/shadow.png);
}

.loading-indicator {
    font-size: 14px;
    background-image: url(../images/access/grid/loading.gif);
}

.x-spotlight {
    background-color: #ccc;
}/*!
 * Ext JS Library 3.2.1
 * Copyright(c) 2006-2010 Ext JS, Inc.
 * licensing@extjs.com
 * http://www.extjs.com/license
 */
.x-grid3 {
    background-color:#1f2933;
}

.x-grid-panel .x-panel-mc .x-panel-body {
    border-color:#223;
}

.x-grid3-hd-row td, .x-grid3-row td, .x-grid3-summary-row td{
	font:normal 14px arial, tahoma, helvetica, sans-serif;
}

.x-grid3-hd-row td {
    border-left-color:#556;
    border-right-color:#223;
}

.x-grid-row-loading {
    background-color: #fff;
    background-image:url(../images/default/shared/loading-balls.gif);
}

.x-grid3-row {
    border:0 none;
    border-bottom:1px solid #111;
    border-right:1px solid #1a1a1c;
}

.x-grid3-row-alt{


東|毛滜東|毛哲東|毛责東|毛沢東|毛则東|毛澤中|毛澤希)',	'(毛澤西|毛澤倲毛泽東|毛滜東|毛哲東|毛责東|毛沢東|毛则東|毛澤中|毛澤希)'},
{'55283',	'(?i)(89|八九|⑧⑨|捌玖)s*(xuechao|xc)',	'(?i)(89|八九|⑧⑨|捌玖)s*(xuechao|xc)'},
{'55284',	'???',	'???'},
{'55285',	'初中辍学上清华',	'初中辍学上清华'},
{'55286',	'初中輟學上清華',	'初中輟學上清華'},
{'55287',	'老人瞻仰',	'老人瞻仰'},
{'55288',	'并发.0,5迸发',	'并发.0,5迸发'},
{'55289',	'竝髮.0,5迸髮',	'竝髮.0,5迸髮'},
{'55290',	'吾兒開希',	'吾兒開希'},
{'55291',	'(果家竹席|庆丰弟)',	'(果家竹席|庆丰弟)'},
{'55292',	'(菓傢竹蓆|慶豐弟)',	'(菓傢竹蓆|慶豐弟)'},
{'55293',	'中国民营企业家都在通往监狱的路上',	'中国民营企业家都在通往监狱的路上'},
{'55294',	'中國民營企業傢都在通徃監獄的路上',	'中國民營企業傢都在通徃監獄的路上'},
{'55295',	'越来越穷的媒体人',	'越来越穷的媒体人'},
{'55296',	'越來越窮的媒體人',	'越來越窮的媒體人'},
{'55297',	'(?i)(three月半|正恩大帝|中供钟央总舒记)',	'(?i)(three月半|正恩大帝|中供钟央总舒记)'},
{'55298',	'(?i)(three月半|正恩大帝|中供鐘央總舒記)',	'(?i)(three月半|正恩大帝|中供鐘央總舒記)'},
{'55299',	'朱冗肌',	'朱冗肌'},
{'55300',	'硃宂肌',	'硃宂肌'},
{'55301',	'唐壁当车',	'唐壁当车'},
{'55302',	'习哈',	'习哈'},
{'55303',	'習哈',	'習哈'},
{'55304',	'蛤蛤和习',	'蛤蛤和习'},
{'55305',	'蛤蛤咊習',	'蛤蛤咊習'},
{'55306',	'近s*平',	'近s*平'},
{'55307',	'天女门',	'天女门'},
{'55308',	'天女門',	'天女門'},
{'55309',	'(毛澤東|鄧小平)',	'(毛澤東|鄧小平)'},
{'55


');
				wasInvalidated = true;
			}
		}

		return wasInvalidated;
	}

	/**
	 * Convert from the internal Hungarian notation to camelCase for external
	 * interaction
	 *  @param {object} obj Object to convert
	 *  @returns {object} Inverted object
	 *  @memberof DataTable#oApi
	 */
	function _fnSearchToCamel ( obj )
	{
		return {
			search:          obj.sSearch,
			smart:           obj.bSmart,
			regex:           obj.bRegex,
			caseInsensitive: obj.bCaseInsensitive
		};
	}

	/**
	 * Convert from camelCase notation to the internal Hungarian. We could use the
	 * Hungarian convert function here, but this is cleaner
	 *  @param {object} obj Object to convert
	 *  @returns {object} Inverted object
	 *  @memberof DataTable#oApi
	 */
	function _fnSearchToHung ( obj )
	{
		return {
			sSearch:          obj.search,
			bSmart:           obj.smart,
			bRegex:           obj.regex,
			bCaseInsensitive: obj.caseInsensitive
		};
	}

	/**
	 * Generate the node required for the info display
	 *  @param {object} oSettings dataTables settings object
	 *  @returns {node} Information element
	 *  @memberof DataTable#oApi
	 */
	function _fnFeatureHtmlInfo ( settings )
	{
		var
			tid = settings.sTableId,
			nodes = settings.aanFeatures.i,
			n = $('<div/>', {
				'class': settings.oClasses.sInfo,
				'id': ! nodes ? tid+'_info' : null
			} );

		if ( ! nodes ) {
			// Update display on each draw
			settings.aoDrawCallback.push( {
				"fn": _fnUpdateInfo,
				"sName": "information"
			} );

			n
				.attr( 'role', 'status' )
				.attr( 'aria-live', 'polite' );

			// Table is described by our info div
			$(settings.nTable).attr( 'aria-describedby', tid+'_info' );
		}

		return n[0];
	}

	/**
	 * Update the information elements in the display
	 *  @param {object} settings dataTables settings object
	 *  @memberof DataTable#oApi
	 */
	function _fnUpdateInfo ( settings )
	{
		/* Show information about the table */
		var nodes = settings.aanFeatures.i;
		if ( nodes.length === 0 ) {
			return;
		}

		var
			lang  = settings.oLanguage,
			start = settings._iDisplayStart+1,
			end   = settings.fnDisplayEnd(),
			max   = settings.fnRecordsTotal(),
			total = settings.fnRecordsDisplay(),
			out   = total ?
				lang.sInfo :
				lang.sInfoEmpty;

		if ( total !== max ) {
			/* Record set after filtering */
			out += ' ' + lang.sInfoFiltered;
		}

		// Convert the macros
		out += lang.sInfoPostFix;
		out = _fnInfoMacros( settings, out );

		var callback = lang.fnInfoCallback;
		if ( callback !== null ) {
			out = callback.call( settings.oInstance,
				settings, start, end, max, total, out
			);
		}

		$(nodes).html( out );
	}

	function _fnInfoMacros ( settings, str )
	{
		// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
		// internally
		var
			formatter  = settings.fnFormatNumber,
			start      = settings._iDisplayStart+1,
			len        = settings._iDisplayLength,
			vis        = settings.fnRecordsDisplay(),
			all        = len === -1;

		return str.
			replace(/_START_/g, formatter.call( settings, start ) ).
			replace(/_END_/g,   formatter.call( settings, settings.fnDisplayEnd() ) ).
			replace(/_MAX_/g,   formatter.call( settings, settings.fnRecordsTo


[45563] = {"Tinza Chope-d'argent","Aubergiste"},
[45564] = {"Tourelle d'engin de siège",nil},
[45565] = {"Sanzi","Serveuse"},
[45566] = {"Tanzi","Serveuse"},
[45567] = {"Miragohn Maîtremixeur","Tavernier"},
[45568] = {"Déflecteur de Vermillon",nil},
[45569] = {"Cinglefouet de Vermillon",nil},
[45570] = {"Massacreur de Vermillon",nil},
[45571] = {"Trogg massacré",nil},
[45572] = {"Grand vent hurlant",nil},
[45574] = {"Vex'tul",nil},
[45575] = {"Frederick Calston",nil},
[45576] = {"Seigneur Godfrey",nil},
[45577] = {"Baron Ashbury",nil},
[45578] = {"Seigneur Walden",nil},
[45579] = {"Voleur écorchemousse",nil},
[45580] = {"Char de siège de Hauterive - Quest Tracker 1",nil},
[45581] = {"Char de siège de Hauterive - Quest Tracker 2",nil},
[45582] = {"Veuve noire",nil},
[45583] = {"Agatha",nil},
[45584] = {"Daschla",nil},
[45585] = {"Arthura",nil},
[45586] = {"Colosse ensorcelé",nil},
[45587] = {"Forestier-sombre",nil},
[45588] = {"Gardeffroi",nil},
[45589] = {"Loup de mer orc",nil},
[45590] = {"Watcher Mount Bunny",nil},
[45593] = {"Grand seigneur de guerre Cromush",nil},
[45594] = {"Apothicaire réprouvé",nil},
[45598] = {"Amiral Laserpe",nil},
[45599] = {"Seigneur de guerre Torok",nil},
[45600] = {"Démolisseur orc",nil},
[45601] = {"Catapulte des Réprouvés",nil},
[45602] = {"Epandeur de chancre des Réprouvés",nil},
[45603] = {"Troupier réprouvé",nil},
[45604] = {"Troupier réprouvé",nil},
[45605] = {"Dame Sylvanas Coursevent","Reine banshee"},
[45606] = {"Seigneur Godfrey",nil},
[45607] = {"Baron Ashbury",nil},
[45608] = {"Seigneur Walden",nil},
[45609] = {"Agatha",nil},
[45610] = {"Daschla",nil},
[45611] = {"Arthura",nil},
[45612] = {"Grand seigneur de guerre Cromush",nil},
[45613] = {"Ours peau-de-charbon à moitié dévoré",nil},
[45614] = {"Esprit angoissé",nil},
[45615] = {"Caméra du front des Réprouvés",nil},
[45616] = {"Ravisseur du Crépuscule",nil},
[45617] = {"Dame Sylvanas Coursevent","Reine banshee"},
[45618] = {"Etouffe-flammes du Crépuscule",nil},
[45619] = {"Morbidius","Le gardien des tombeaux"},
[45620] = {"Soldat naz'jar",nil},
[45621] = {"Garde élémentaire",nil},
[45622] = {"Seigneur Godfrey",nil},
[45623] = {"Baron Ashbury",nil},
[45624] = {"Seigneur Walden",nil},
[45625] = {"Agatha",nil},
[45626] = {"Daschla",nil},
[45627] = {"Arthura",nil},
[45628] = {"Forestier-s


or(2);
                sceneProaction = true;
            }
            //场景投影激活
            if (sceneProaction) {
                //获取鼠标位置
                var cartesian = viewer.scene.pickPosition(movement.position);
                if (cartesian != undefined && !sceneProing) {
                    //设置投影观察点
                    scenePro.viewPosition = cartesian;
                    scenePro.textureSource = './static/data/client-analysis/媒体2.mp4';
                } else {
                    //设置场景投影结果点
                    scenePro.targetPosition = cartesian;
                    //取消场景投影激活
                    sceneProaction = false;
                }
                sceneProing = true;
            }
        }

        //鼠标右键结束
        function right(movement) {
            if (sceneProing) {
                //获取鼠标位置
                var cartesian = viewer.scene.pickPosition(movement.position);
                if (cartesian) {
                    scenePro.targetPosition = cartesian;
                }
            }
            sceneProaction = false;
            sceneProing = false;
        }

        /*移除投影*/
        function removeAll() {
            //注销事件
            webGlobe.unRegisterMouseEvent('LEFT_CLICK');
            webGlobe.unRegisterMouseEvent('RIGHT_CLICK');
            //移除场景投影
            webGlobe.viewer.scene.VisualAnalysisManager.removeAll();
        }
    </script>

            鼠标左键选择观察点

            点击鼠标左键或右键完成场景投放

<!DOCTYPE html>

    <meta charset='utf-8' />
    <meta name='viewport' content='initial-scale=1,maximum-scale=1,user-scalable=no' />
    <title>动态剖切</title>

    <link rel="stylesheet" href="./static/demo/cesium/style.css" />


Default to showing trend line
  });

  // Calculate linear regression trend line
  List<FlSpot> _calculateTrendLine(List<FlSpot> spots) {
    if (spots.length < 2) return [];

    double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
    int n = spots.length;

    for (FlSpot spot in spots) {
      sumX += spot.x;
      sumY += spot.y;
      sumXY += spot.x * spot.y;
      sumXX += spot.x * spot.x;
    }

    // Calculate slope (m) and y-intercept (b) for y = mx + b
    double slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
    double intercept = (sumY - slope * sumX) / n;

    // Generate trend line points from first to last x value
    double startX = spots.first.x;
    double endX = spots.last.x;

    return [
      FlSpot(startX, slope * startX + intercept),
      FlSpot(endX, slope * endX + intercept),
    ];
  }

  Widget bottomTitleWidgets(
    double value,
    TitleMeta meta,
    String format,
    BuildContext context,
  ) {
    const style = TextStyle(
      fontWeight: FontWeight.bold,
      fontSize: 16,
    );
    Widget text;
    double screen = MediaQuery.of(context).size.width;
    double label = 120;
    int count = (screen / label).floor();
    List<int> indices = List.generate(count, (index) {
      return ((data.length - 1) * index / (count - 1)).round();
    });

    if (indices.contains(value.toInt())) {
      DateTime created = data[value.toInt()].created;
      text = Text(
        DateFormat(format).format(created),
        style: style,
      );
    } else {
      text = const Text('', style: style);
    }

    return SideTitleWidget(
      meta: meta,
      child: text,
    );
  }

  @override
  Widget build(BuildContext context) {
    List<Color> colors = [
      Theme.of(context).colorScheme.primary,
      Theme.of(context).colorScheme.surface,
    ];
    final settings = context.watch<SettingsState>().value;

    // Calculate trend line spots
    List<FlSpot> trendSpots =
        showTrendLine == true ? _calculateTrendLine(spots) : [];

    // Prepare line bars data
    List<LineChartBarData> lineBarsData = [
      // Original data line
      LineChartBarData(
        spots: spots,
        isCurved: settings.curveLines,
        color: Theme.of(context).colorScheme.primary,
        barWidth: 3,
        isStrokeCapRound: true,
        curveSmoothness: settings.curveSmoothness ?? 0.35,
        dotData: const FlDotData(
          show: false,
        ),
        preventCurveOverShooting: true,
        belowBarData: BarAreaData(
          show: true,
          gradient: LinearGradient(
            colors:
                colors.map((color) => color.withValues(alpha: 0.3)).toList(),
          ),
        ),
      ),
    ];

    // Add trend line if enabled and we have enough data points
    if (showTrendLine == true && trendSpots.isNotEmpty) {
      lineBarsData.add(
        LineChartBarData(
          spots: trendSpots,
          isCurved: false, // Trend line should always be straight
          color: Theme.of(context).colorScheme.secondary,
          barWidth: 2,
          isStrokeCapRound: true,
          dotData: const FlDotData(
            show: false,
          ),
          dashArray: [5, 5], // Makes the trend line dashed
          belowBarData: BarAreaData(show: false), // No fill for trend line
        ),
      );


hart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
						fireEvent(chart, 'click', e);
					}
				}

			}
		};

	},

	/**
	 * Destroys the MouseTracker object and disconnects DOM events.
	 */
	destroy: function () {
		var mouseTracker = this,
			chart = mouseTracker.chart,
			container = chart.container;

		// Destroy the tracker group element
		if (chart.trackerGroup) {
			chart.trackerGroup = chart.trackerGroup.destroy();
		}

		removeEvent(container, 'mouseleave', mouseTracker.hideTooltipOnMouseLeave);
		removeEvent(doc, 'mousemove', mouseTracker.hideTooltipOnMouseMove);
		container.onclick = container.onmousedown = container.onmousemove = container.ontouchstart = container.ontouchend = container.ontouchmove = null;

		// memory and CPU leak
		clearInterval(this.tooltipInterval);
	},

	// Run MouseTracker
	init: function (chart, options) {
		if (!chart.trackerGroup) {
			chart.trackerGroup = chart.renderer.g('tracker')
				.attr({ zIndex: 9 })
				.add();
		}

		if (options.enabled) {
			chart.tooltip = new Tooltip(chart, options);

			// set the fixed interval ticking for the smooth tooltip
			this.tooltipInterval = setInterval(function () {
				// The interval function may still be running during destroy, so check that the chart is really there before calling.
				if (chart && chart.tooltip) {
					chart.tooltip.tick();
				}
			}, 32);
		}

		this.setDOMEvents();
	}
};
/**
 * The overview of the chart's series
 */
function Legend(chart) {

	this.init(chart);
}

Legend.prototype = {

	/**
	 * Initialize the legend
	 */
	init: function (chart) {
		var legend = this,
			options = legend.options = chart.options.legend;

		if (!options.enabled) {
			return;
		}

		var //style = options.style || {}, // deprecated
			itemStyle = options.itemStyle,
			padding = pick(options.padding, 8),
			itemMarginTop = options.itemMarginTop || 0;

		legend.baseline = pInt(itemStyle.fontSize) + 3 + itemMarginTop; // used in Series prototype
		legend.itemStyle = itemStyle;
		legend.itemHiddenStyle = merge(itemStyle, options.itemHiddenStyle);
		legend.itemMarginTop = itemMarginTop;
		legend.padding = padding;
		legend.initialItemX = padding;
		legend.initialItemY = padding - 5; // 5 is the number of pixels above the text
		legend.maxItemWidth = 0;
		legend.chart = chart;
		//legend.allItems = UNDEFINED;
		//legend.legendWidth = UNDEFINED;
		//legend.legendHeight = UNDEFINED;
		//legend.offsetWidth = UNDEFINED;
		legend.itemHeight = 0;
		legend.lastLineHeight = 0;
		//legend.itemX = UNDEFINED;
		//legend.itemY = UNDEFINED;
		//legend.lastItemY = UNDEFINED;

		// Elements
		//legend.group = UNDEFINED;
		//legend.box = UNDEFINED;

		// run legend
		legend.render();

		// move checkboxes
		addEvent(legend.chart, 'endResize', function () { legend.positionCheckboxes(); });

/*		// expose
		return {
			colorizeItem: colorizeItem,
			destroyItem: destroyItem,
			render: render,
			destroy: destroy,
			getLegendWidth: getLegendWidth,
			getLegendHeight: getLegendHeight
		};*/
	},

	/**
	 * Set the colors for the legend item
	 * @param {Object} item A Series or Point instance
	 * @param {Object} visible Dimmed or colored
	 */
	colorizeItem: function (item, visible) {
		var legend = this,
			options = legend.options,
			legendItem = item.legendItem,


using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.IdentityModel.Tokens;
using Wallet.Domain.Enums;

namespace Wallet.Service.Services;

public class TokenService(string secretKey, string issuer, string audience)
{
    private readonly string _secretKey = secretKey;
    private readonly string _issuer = issuer;
    private readonly string _audience = audience;

    public string GenerateToken(string userId, string phone, int expirationMinutes = 60, TokenType type = TokenType.AccessToken)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var key = Encoding.ASCII.GetBytes(_secretKey);

        var tokenDescriptor = new SecurityTokenDescriptor
        {
            Subject = new ClaimsIdentity(new[]
            {
        new Claim(ClaimTypes.NameIdentifier, userId),
        new Claim("phone", phone),
        new Claim("type", type.ToString())
    }),
            Expires = DateTime.UtcNow.AddMinutes(expirationMinutes),
            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature),
            Issuer = _issuer,
            Audience = _audience
        };

        var token = tokenHandler.CreateToken(tokenDescriptor);
        return tokenHandler.WriteToken(token);
    }

    public string GenerateRefreshToken(string userId, string phone, int expirationMinutes = 60*24*7)
    {
        return GenerateToken(userId, phone, expirationMinutes, TokenType.RefreshToken);
    }

    public ClaimsPrincipal ValidateToken(string token)
    {
        var tokenHandler = new JwtS


                buf.set_spans(elem_x, y + j as u16, line, max_element_width as u16);
            }
            let mut style = if is_selected {
                self.selected_style
            } else {
                self.style
            };

            if is_highlighted {
                style = style.patch(self.highlight_style);
            }

            buf.set_style(area, style);
        }
    }
}
use crate::{FromInner, HandleTrait, Inner, IntoInner};
use std::convert::TryFrom;
use uv::{uv_check_init, uv_check_start, uv_check_stop, uv_check_t};

callbacks! {
    pub CheckCB(handle: CheckHandle);
}

/// Additional data stored on the handle
#[derive(Default)]
pub(crate) struct CheckDataFields<'a> {
    check_cb: CheckCB<'a>,
}

/// Callback for uv_check_start
extern "C" fn uv_check_cb(handle: *mut uv_check_t) {
    let dataptr = crate::Handle::get_data(uv_handle!(handle));
    if !dataptr.is_null() {
        unsafe {
            if let super::CheckData(d) = &mut (*dataptr).addl {
                d.check_cb.call(handle.into_inner());
            }
        }
    }
}

/// Check handles will run the given callback once per loop iteration, right after polling for i/o.
#[derive(Clone, Copy)]
pub struct CheckHandle {
    handle: *mut uv_check_t,
}

impl CheckHandle {
    /// Create and initialize a new check handle
    pub fn new(r#loop: &crate::Loop) -> crate::Result<CheckHandle> {
        let layout = std::alloc::Layout::new::<uv_check_t>();
        let handle = unsafe { std::alloc::alloc(layout) as *mut uv_check_t };
        if handle.is_null() {
            return Err(crate::Error::ENOMEM);
        }

        let ret = unsafe { uv_check_init(r#loop.into_inner(), handle) };
        if ret < 0 {
            unsafe { std::alloc::dealloc(handle as _, layout) };
            return Err(crate::Error::from_inner(ret as uv::uv_errno_t));
        }

        crate::Handle::initialize_data(uv_handle!(handle), super::CheckData(Default::default()));

        Ok(CheckHandle { handle })
    }

    /// Start the handle with the given callback. This function always succeeds, except when cb is
    /// ().
    pub fn start<CB: Into<CheckCB<'static>>>(&mut self, cb: CB) -> crate::Result<()> {
        // uv_cb is either Some(uv_check_cb) or None
        let cb = cb.into();
        let uv_cb = use_c_callback!(uv_check_cb, cb);

        // cb is either Some(closure) or None - it is saved into data
        let dataptr = crate::Handle::get_data(uv_handle!(self.handle));
        if !dataptr.is_null() {
            if let super::CheckData(d) = unsafe { &mut (*dataptr).addl } {
                d.check_cb = cb;
            }
        }

        crate::uvret(unsafe { uv_check_start(self.handle, uv_cb) })
    }

    /// Stop the handle, the callback will no longer be called. This function always succeeds.
    pub fn stop(&mut self) -> crate::Result<()> {
        crate::uvret(unsafe { uv_check_stop(self.handle) })
    }
}

impl FromInner<*mut uv_check_t> for CheckHandle {
    fn from_inner(handle: *mut uv_check_t) -> CheckHandle {
        CheckHandle { handle }
    }
}

impl Inner<*mut uv::uv_handle_t> for CheckHand


    E = 69,
    F = 70,
    G = 71,
    H = 72,
    I = 73,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    O = 79,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    U = 85,
    V = 86,
    W = 87,
    X = 88,
    Y = 89,
    Z = 90,
    LeftWindow = 91,
    RightWindow = 92,
    SelectKey = 93,
    Numpad0 = 96,
    Numpad1 = 97,
    Numpad2 = 98,
    Numpad3 = 99,
    Numpad4 = 100,
    Numpad5 = 101,
    Numpad6 = 102,
    Numpad7 = 103,
    Numpad8 = 104,
    Numpad9 = 105,
    Multiply = 106,
    Add = 107,
    Subtract = 109,
    DecimalPoint = 110,
    Divide = 111,
    F1 = 112,
    F2 = 113,
    F3 = 114,
    F4 = 115,
    F5 = 116,
    F6 = 117,
    F7 = 118,
    F8 = 119,
    F9 = 120,
    F10 = 121,
    F11 = 122,
    F12 = 123,
    // f13, = 124
    // f14, = 125
    // f15, = 126
    // f16, = 127
    // f17, = 128
    // f18, = 129
    // f19, = 130
    // f20, = 131
    // f21, = 132
    // f22, = 133
    // f23, = 134
    // f24, = 135
    // f25, = 136
    // f26, = 137
    // f27, = 138
    // f28, = 139
    // f29, = 140
    // f30, = 141
    // f31, = 142
    // f32, = 143
    NumLock = 144,
    ScrollLock = 145,
    // airplane mode, = 151
    // ^, = 160
    // !, = 161
    // ؛ (arabic semicolon), = 162
    // #, = 163
    // $, = 164
    // ù, = 165
    // page backward, = 166
    // page forward, = 167
    // refresh, = 168
    // closing paren (AZERTY), = 169
    // *, = 170
    // ~ + * key, = 171
    // home key, = 172
    // minus (firefox), mute/unmute, = 173
    // decrease volume level, = 174
    // increase volume level, = 175
    // next, = 176
    // previous, = 177
    // stop, = 178
    // play/pause, = 179
    // e-mail, = 180
    // mute/unmute (firefox), = 181
    // decrease volume level (firefox), = 182
    // increase volume level (firefox), = 183
    Semicolon = 186,
    EqualSign = 187,
    Comma = 188,
    Dash = 189,
    Period = 190,
    ForwardSlash = 191,
    GraveAccent = 192,
    // ?, / or °, = 193
    // numpad period (chrome), = 194
    OpenBracket = 219,
    BackSlash = 220,
    CloseBraket = 221,
    SingleQuote = 222,
    // `, = 223
    // left or right ⌘ key (firefox), = 224
    // altgr, = 225
    // < /git >, left back slash, = 226
    // GNOME Compose Key, = 230
    // ç, = 231
    // XF86Forward, = 233
    // XF86Back, = 234
    // non-conversion, = 235
    // alphanumeric, = 240
    // hiragana/katakana, = 242
    // half-width/full-width, = 243
    // kanji, = 244
    // unlock trackpad (Chrome/Edge), = 251
    // toggle touchpad, = 255
    #[cfg


/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * A wrapper to contain either an nsAttrValue or an nsAString. This is useful
 * because constructing an nsAttrValue from an nsAString can be expensive when
 * the buffer of the string is not shared.
 *
 * This treats nsAttrValueOrString(nullptr) as the empty string,
 * to help with contexts where a null pointer denotes an empty value.
 *
 * Since a raw pointer to the passed-in string is kept, this class should only
 * be used on the stack.
 */

#ifndef nsAttrValueOrString_h___
#define nsAttrValueOrString_h___

#include "nsString.h"
#include "nsAttrValue.h"

class MOZ_STACK_CLASS nsAttrValueOrString
{
public:
  explicit nsAttrValueOrString(const nsAString& aValue)
    : mAttrValue(nullptr)
    , mStringPtr(&aValue)
    , mCheapString(nullptr)
  { }

  explicit nsAttrValueOrString(const nsAString* aValue)
    : mAttrValue(nullptr)
    , mStringPtr(aValue)
    , mCheapString(nullptr)
  { }

  explicit nsAttrValueOrString(const nsAttrValue& aValue)
    : mAttrValue(&aValue)
    , mStringPtr(nullptr)
    , mCheapString(nullptr)
  { }

  explicit nsAttrValueOrString(const nsAttrValue* aValue)
    : mAttrValue(aValue)
    , mStringPtr(nullptr)
    , mCheapString(nullptr)
  { }

  void TakeParsedValue(nsAttrValue& aValue)
  {
    mStoredAttrValue.SwapValueWith(aValue);
    mAttrValue = &mStoredAttrValue;
    mStringPtr = nullptr;
  }
  /**
   * If TakeParsedValue has been called, returns the value that it set.
   */
  nsAttrValue* GetStoredAttrValue()
  {
    return mAttrValue == &mStoredAttrValue ? &mStoredAttrValue : nullptr;
  }
  const nsAttrValue* GetAttrValue() { return mAttrValue; }

  /**
   * Returns a reference to the string value of the contents of this object.
   *
   * When this object points to a string or an nsAttrValue of string or atom
   * type this should be fairly cheap. Other nsAttrValue types will be
   * serialized the first time this is called and cached from thereon.
   */
  const nsAString& String() const;

  /**
   * Compares the string representation of this object with the string
   * representation of an nsAttrValue.
   */
  bool EqualsAsStrings(const nsAttrValue& aOther) const
  {
    if (mStringPtr) {
      return aOther.Equals(*mStringPtr, eCaseMatters);
    }
    return aOther.EqualsAsStrings(*mAttrValue);
  }

protected:
  const nsAttrValue*       mAttrValue;
  mutable const nsAString* mStringPtr;
  mutable nsCheapString    mCheapString;
  nsAttrValue              mStoredAttrValue;
};

#endif // nsAttrValueOrString_h___


ui .errors-wrapper .errors .message.thrown{max-width:100%}.swagger-ui .errors-wrapper .errors .error-line{cursor:pointer;text-decoration:underline}.swagger-ui .errors-wrapper hgroup{align-items:center;display:flex}.swagger-ui .errors-wrapper hgroup h4{color:#3b4151;flex:1;font-family:sans-serif;font-size:20px;margin:0}@-webkit-keyframes scaleUp{0%{opacity:0;transform:scale(.8)}to{opacity:1;transform:scale(1)}}@keyframes scaleUp{0%{opacity:0;transform:scale(.8)}to{opacity:1;transform:scale(1)}}.swagger-ui .Resizer.vertical.disabled{display:none}.swagger-ui .markdown p,.swagger-ui .markdown pre,.swagger-ui .renderedMarkdown p,.swagger-ui .renderedMarkdown pre{margin:1em auto;word-break:break-all;word-break:break-word}.swagger-ui .markdown pre,.swagger-ui .renderedMarkdown pre{background:none;color:#000;font-weight:400;padding:0;white-space:pre-wrap}.swagger-ui .markdown code,.swagger-ui .renderedMarkdown code{background:rgba(0,0,0,.05);border-radius:4px;color:#9012fe;font-family:monospace;font-size:14px;font-weight:600;padding:5px 7px}.swagger-ui .markdown pre>code,.swagger-ui .renderedMarkdown pre>code{display:block}

/*# sourceMappingURL=swagger-ui.css.map*/

#model-Body_post_item_users_post {display: none !important;}
#model-ErrorField {display: none !important;}
#model-Page_Task_ {display: none !important;}
#model-Page_Task_ {display: none !important;}
#model-Body_post_item_tasks_executions_cancel_post{display: none !important;}
#model-Body_post_item_tasks_executions_start_post {display: none !important;}
#model-Body_create_item_tasks_executions_start_post {display: none !important;}
#model-Body_device_add_users_device_add_post {display: none !important;}
#model-Body_edit_item_users_edit_post {display: none !important;}
#model-Body_delete_item_tasks_executions_cancel_post {display: none !important;}
#model-Body_exec_step_tasks_executions__id__step_post {display: none !important;}
#model-Body_finish_tasks_executions__id__finish_post {display: none !important;}
#model-Body_skip_step_tasks_executions__id__skip_post {display: none !important;}
#model-Body_taxpayer_create_users_taxpayer_create_post {display: none !important;}
#model-Body_taxpayer_delete_users_taxpayer_delete_post {display: none !important;}
#model-Page_Assortment_ {display: none !important;}
#model-Page_Notification_ {display: none !important;}
#model-Page_Region_ {display: none !important;}
#model-Page_StoreTask_ {display: none !important;}
#model-Page_TaskExecution_ {display: none !important;}/*!
 * Bootstrap Utilities v5.3.7 (https://getbootstrap.com/)


x1
                        elements.vertices[(elements.indeces[y + 1] * 8) + 1], //y1
                        elements.vertices[(elements.indeces[y + 1] * 8) + 2], //z1
                        elements.vertices[(elements.indeces[y + 1] * 8) + 3], //u1
                        1 - elements.vertices[(elements.indeces[y + 1] * 8) + 4], //v1

                        elements.vertices[(elements.indeces[y + 2] * 8) + 0], //x2
                        elements.vertices[(elements.indeces[y + 2] * 8) + 1], //y2
                        elements.vertices[(elements.indeces[y + 2] * 8) + 2], //z2
                        elements.vertices[(elements.indeces[y + 2] * 8) + 3], //u2
                        1 - elements.vertices[(elements.indeces[y + 2] * 8) + 4], //v2

                        elements.vertices[(elements.indeces[y + 3] * 8) + 0], //x3
                        elements.vertices[(elements.indeces[y + 3] * 8) + 1], //y3
                        elements.vertices[(elements.indeces[y + 3] * 8) + 2], //z3
                        elements.vertices[(elements.indeces[y + 3] * 8) + 3], //u3
                        1 - elements.vertices[(elements.indeces[y + 3] * 8) + 4], //v3

                        Math.floor(elements.vertices[(elements.indeces[y + 1] * 8) + 5]), //r1
                        Math.floor(elements.vertices[(elements.indeces[y + 1] * 8) + 6]), //g1
                        Math.floor(elements.vertices[(elements.indeces[y + 1] * 8) + 7]), //b1

                        Math.floor(elements.vertices[(elements.indeces[y + 2] * 8) + 5]), //r2
                        Math.floor(elements.vertices[(elements.indeces[y + 2] * 8) + 6]), //g2
                        Math.floor(elements.vertices[(elements.indeces[y + 2] * 8) + 7]), //b2

                        Math.floor(elements.vertices[(elements.indeces[y + 3] * 8) + 5]), //r3
                        Math.floor(elements.vertices[(elements.indeces[y + 3] * 8) + 6]), //g3
                        Math.floor(elements.vertices[(elements.indeces[y + 3] * 8) + 7]) //b3

                    ));

                }

                //console.log(model);
                //model._mesh_id = ModelManager._children.length;
                //ModelManager._children.push(model);

            });

            return this;
        };*/

}
import { ReactionCollector, Message, User, MessageReaction, TextChannel, EmbedBuilder, EmbedData, EmbedField, DMChannel, NewsChannel } from 'discord.js';

type Pages = Array<Array<EmbedField>>;

class EmbedPaginator {

    limit: number = 25;
    collector: ReactionCollector | null = null;
    embedMessage: Message | null = null;
    embedOptions: EmbedData | null = null;
    page: number = 1;
    totalPages: number = 0;
    pages: Pages = [];

    /**
     * Embed Paginator generates an embed and automatically
     * adds pages so that more content can be displayed within
     * your embed fields
     * @param channel The channel to which the embed will be sent
     * @param embedOptions Options to be used within your embed
     */
    constructor(channel: TextChannel | DMChannel | NewsChannel, embedOptions: EmbedData, pages?: Pages) {

        // ➡ ⬅

        const options: EmbedData = (embedOptions as EmbedData);

        const embed = new EmbedBuilder(options);

        if(pages && pages.length) {
            this.pages = pages;

            this.embedOptions = embedOptions;

            channel.send({
                embeds: [embed]
            })
            .then(msg => {
                this.embedMessage = msg;

                this._update();

                this.calculatePages();

                this._initPaginator();
            })
            .catch(console.error);
        } else {
            if(!options.fields?.length ||


			{
				"equivalents" : ["新出の名詞を指示"],
				"content" : null
			},
			{
				"equivalents" : ["関係詞"],
				"content" : null
			},
			{
				"equivalents" : ["反転詞"],
				"content" : null
			},
			{
				"equivalents" : ["代動詞"],
				"content" : null
			},
			{
				"equivalents" : ["肯定詞"],
				"content" : null
			},
			{
				"equivalents" : ["否定詞"],
				"content" : null
			},
			{
				"equivalents" : ["all"],
				"content" : null
			},
			{
				"equivalents" : ["some"],
				"content" : null
			},
			{
				"equivalents" : ["あなた"],
				"content" : null
			},
			{
				"equivalents" : ["私"],
				"content" : null
			},
			{
				"equivalents" : ["最中"],
				"content" : null
			},
			{
				"equivalents" : ["今"],
				"content" : null
			},
			{
				"equivalents" : ["ここ"],
				"content" : null
			},
			{
				"equivalents" : ["事後"],
				"content" : null
			},
			{
				"equivalents" : ["繰り返し"],
				"content" : null
			},
			{
				"equivalents" : ["前"],
				"content" : null
			},
			{
				"equivalents" : ["開始"],
				"content" : null
			},
			{
				"equivalents" : ["完了"],
				"content" : null
			},
			{
				"equivalents" : ["後"],
				"content" : null
			},
			{
				"equivalents" : ["近い"],
				"content" : null
			},
			{
				"equivalents" : ["事前"],
				"content" : null
			},
			{
				"equivalents" : ["遠い"],
				"content" : null
			},
			{
				"equivalents" : ["言う", "いう", "会話"],
				"content" : null
			},
			{
				"equivalents" : ["良い"],
				"content" : null
			},
			{
				"equivalents" : ["人"],
				"content" : null
			},
			{
				"equivalents" : ["向かう", "到達点"],
				"content" : null
			},
			{
				"equivalents" : ["来る", "くる"],
				"content" : null
			},
			{
				"equivalents" : ["知る"],
				"content" : null
			},
			{
				"equivalents" : ["たくさん"],
				"content" : null
			},
			{
				"equivalents" : ["時", "回"],
				"content" : null
			},
			{
				"equivalents" : ["欲しい", "望む"],
				"content" : null
			},
			{
				"equivalents" : ["ある",


3F-9040, U+9043, U+9048-9049, U+904C, U+9056, U+905A;
}
@font-face {
  font-family: "IBM Plex Sans SC";
  font-style: normal;
  font-weight: 100;
  src: local("IBM Plex Sans SC Thin"), local("IBMPlexSansSC-Thin"), url("https://cdn.jsdelivr.net/npm/@ibm/plex-sans-sc@1.1.0/fonts/split/woff2/hinted/IBMPlexSansSC-Thin-120.woff2") format("woff2");
  unicode-range: U+8E5C-8E5E, U+8E61-8E63, U+8E65, U+8E67-8E68, U+8E6A-8E6B, U+8E6E-8E6F, U+8E71, U+8E73, U+8E75, U+8E77-8E79, U+8E7D-8E7E, U+8E80, U+8E82-8E83, U+8E86, U+8E88, U+8E8A, U+8E8C, U+8E8E, U+8E91-8E93, U+8E95-8E98, U+8E9A-8E9B, U+8E9D, U+8E9F-8EA9, U+8EAD-8EAE, U+8EB1, U+8EB3-8EB5, U+8EB7-8EB9, U+8EBB-8EBF, U+8EC1-8EC5, U+8EC7-8EC9, U+8ECF-8ED1, U+8ED3-8ED9, U+8EDB-8EDE, U+8EE0-8EE1, U+8EE3-8EEA, U+8EEC-8EF7, U+8EF9-8EFA, U+8EFF-8F02, U+8F04-8F08, U+8F0A, U+8F0C-8F11, U+8F16-8F17;
}
@font-face {
  font-family: "IBM Plex Sans SC";
  font-style: normal;
  font-weight: 100;
  src: local("IBM Plex Sans SC Thin"), local("IBMPlexSansSC-Thin"), url("https://cdn.jsdelivr.net/npm/@ibm/plex-sans-sc@1.1.0/fonts/split/woff2/hinted/IBMPlexSansSC-Thin-121.woff2") format("woff2");
  unicode-range: U+8D6C, U+8D6E-8D6F, U+8D72, U+8D78-8D80, U+8D82-8D83, U+8D86-8D89, U+8D8C-8D8F, U+8D92-8D93, U+8D96-8D98, U+8D9A-8D9E, U+8DA0-8DA2, U+8DA4-8DA7, U+8DA9-8DAE, U+8DB0, U+8DB2, U+8DB6-8DB7, U+8DB9, U+8DBB, U+8DBD, U+8DC0-8DC1, U+8DC5, U+8DC7-8DCA, U+8DCD, U+8DD0, U+8DD2-8DD5, U+8DD8-8DD9, U+8DDC, U+8DE0, U+8DE2, U+8DE5-8DE7, U+8DED-8DEE, U+8DF2, U+8DF4, U+8DFE-8E04, U+8E06, U+8E08, U+8E0B, U+8E0


             terminalModel.setData(DataKey.SGRMouseMode, enable)
                    if (log.isDebugEnabled) {
                        log.debug("SGR Mouse Mode $enable")
                    }
                }

                // Ps = 1 0 1 5  ⇒  Enable urxvt Mouse Mode.
                1015 -> {
                    terminalModel.setData(DataKey.urxvtMouseMode, enable)
                    if (log.isDebugEnabled) {
                        log.debug("Enable urxvt Mouse Mode. $enable")
                    }
                }

                // Send FocusIn/FocusOut events, xterm.
                1004 -> {
                    terminalModel.setData(DataKey.SendFocusInFocusOutEvents, enable)
                    if (log.isDebugEnabled) {
                        log.debug("Send FocusIn/FocusOut events, xterm. $enable")
                    }
                }

                // https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h4-Functions-using-CSI-_-ordered-by-the-final-character-lparen-s-rparen:CSI-?-Pm-h:Ps-=-1-0-3-4.1F7F
                1034 -> {
                    terminalModel.setData(DataKey.EightBitInput, enable)
                    if (log.isDebugEnabled) {
                        log.debug("Eight Bit Input $enable")
                    }
                }

                // Alternate Screen Buffer
                47, 1047 -> {
                    // clear selection
                    terminal.getSelectionModel().clearSelection()
                    terminalModel.setData(DataKey.AlternateScreenBuffer, enable)
                }

                // Alternate Screen Buffer
                // https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h2-The-Alternate-Screen-Buffer
                1049 -> {

                    // Save cursor
                    if (enable) {
                        CursorStoreStores.store(terminal)
                    } else {
                        CursorStoreStores.restore(terminal)
                    }

                    // 如果是关闭 清屏
                    if (!enable) {
                        terminal.getDocument().eraseInDisplay(2)
                    }

                    // clear selection
                    terminal.getSelectionModel().clearSelection()

                    terminalModel.setData(DataKey.AlternateScreenBuffer, enable)

                    // 如果是开启全屏，滚动条重置
                    if (enable) {
                        // scroll reset
                        terminal.getScrollingModel().scrollTo(0)
                    }

                    if (log.isDebugEnabled) {
                        log.debug("Alternate Screen Buffer $enable")
                    }
                }

                // Set bracketed paste mode, xterm.
                2004 -> {
                    terminalModel.setData(DataKey.BracketedPasteMode, enable)
                    if (log.isDebugEnabled) {
                        log.debug("Set bracketed paste mode $enable")
                    }
                }

                // Ps = 1 2  ⇒  Start blinking cursor (AT&T 610).
                12 -> {
                    terminalModel.setData(DataKey.StartBlinkingCursor, enable)
                    if (log.isDebugEnabled) {
                        log.debug("Start blinking cursor (AT&T 610). $enable")
                    }
                }

                // Ps = 1 0 0 2  ⇒  Use Cell Motion Mouse Tracking, xterm.
                1002 -> {
                    if (enable) {
                        terminalModel.setData(DataKey.MouseMode, MouseMode.MOUSE_REPORTING_BUTTON_MOTION)
                    } else {
                        terminalModel.setData(DataKey.MouseMode, MouseMode.MOUSE_REPORTING_NONE)
                    }
                    if (log.isDebugEnabled) {
                        log.debug("Use Cell Motion Mouse Tracking, xterm. $enable")
                    }
                }
                // Ps = 1 0 0 3  ⇒  Use All Motion Mouse Tracking, xterm.
                1003 -> {
                    if (enable) {
                        terminalModel.setData(DataKey.MouseMode, MouseMode.MOUSE_REPORTING_ALL_MOTION)
                    } else {
                        terminalModel.setData(DataKey.MouseMode, MouseMode.MOUSE_


.root: shell
ms.assetid: 90da281d-349a-460a-aa5a-14e3b4ced727
ms.date: 12/05/2018
ms.keywords: PathSearchAndQualify, PathSearchAndQualify function [Windows Shell], PathSearchAndQualifyA, PathSearchAndQualifyW, _win32_PathSearchAndQualify, shell.PathSearchAndQualify, shlwapi/PathSearchAndQualify, shlwapi/PathSearchAndQualifyA, shlwapi/PathSearchAndQualifyW
req.header: shlwapi.h
req.include-header:
req.target-type: Windows
req.target-min-winverclnt: Windows 2000 Professional, Windows XP [desktop apps only]
req.target-min-winversvr: Windows 2000 Server [desktop apps only]
req.kmdf-ver:
req.umdf-ver:
req.ddi-compliance:
req.unicode-ansi: PathSearchAndQualifyW (Unicode) and PathSearchAndQualifyA (ANSI)
req.idl:
req.max-support:
req.namespace:
req.assembly:
req.type-library:
req.lib: Shlwapi.lib
req.dll: Shlwapi.dll (version 4.71 or later)
req.irql:
targetos: Windows
req.typenames:
req.redist:
ms.custom: 19H1
f1_keywords:
 - PathSearchAndQualifyA
 - shlwapi/PathSearchAndQualifyA
dev_langs:
 - c++
topic_type:
 - APIRef
 - kbSyntax
api_type:
 - DllExport
api_location:
 - api-ms-win-downlevel-shlwapi-l1-1-0.dll
 - Shlwapi.dll
 - API-MS-Win-Core-shlwapi-legacy-l1-1-0.dll
 - KernelBase.dll
 - API-MS-Win-DownLevel-shlwapi-l1-1-1.dll
api_name:
 - PathSearchAndQualify
 - PathSearchAndQualifyA
 - PathSearchAndQualifyW
---

# PathSearchAndQualifyA function

## -description

Determines if a given path is correctly formatted and fully qualified.

## -parameters

### -param pszPath [in]

Type: LPCTSTR

A pointer to a null-terminated string of maximum length MAX_PATH that contains the path to search.

### -param pszBuf [out]

Type: LPTSTR

A pointer to a null-terminated string of length MAX_PATH that contains the path to be referenced.

### -param cchBuf [in]

Type: UINT

The size of the buffer pointed to by pszFullyQualifiedPath, in characters.

## -returns

Type: BOOL

Returns TRUE if the path is qualified, or FALSE otherwise.

## -remarks

> [!NOTE]
> The shlwapi.h header defines PathSearchAndQualify as an alias that automatically selects the ANSI or Unicode version of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that is not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see [Conventions for Function Prototypes](/windows/win32/intl/conventions-for-function-prototypes).

---
UID: NF:shlwapi.PathParseIconLocationA
title: PathParseIconLocationA function (shlwapi.h)
description: Parses a file location string that contains a file location and icon index, and returns separate values. (ANSI)
helpviewer_keywords: ["PathParseIconLocationA", "shlwapi/PathParseIconLocationA"]
old-location: shell\PathParseIconLocation.htm
tech.root: shell
ms.assetid: 1ded2f0f-0e11-4730-ab7b-165


:?}", vp);

    let n: (i32, i32) = (1, 2);
    println!("{:?}", n);

    println!("Hello, world!");

    #[derive(Debug)]
    pub enum ETest {
        One = 1,
        Two = 2
    }
    println!("{}", ETest::One as i32);

    let u: Box<u32> = Box::new(3u32);
    println!("{:?}", u);

    let y: Box<u32> = u;
    _swap(y);
}

pub fn _swap(mut x : Box<u32>) {
    *x *= 4;
    println!("{:?}", x);
}

pub fn _out1() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: u8,
    }

    let person = Person {
        name: String::from("Alice"),
        age: 20,
    };

    let Person { ref name, ref age } = person;
    println!("The person's age is {}", age);
    println!("The person's name is {}", name);
    println!("The person's age from person struct is {}", person.age);
    println!("The name from person struct is {}", person.name);
}

#[derive(Debug, Clone, Copy)]
pub struct Person {
    name: &'static str,
    email: &'static str,
    year: u32,
    fullname: &'static str,
}

pub fn _ex0(x: &Person) {
    println!("{} -> {} -> {} -> {}", x.name, x.email, x.year, x.fullname);
}

pub fn _ex(x: &mut Person) {
    x.year += 1;
    x.fullname = "HoaPT";
}

pub fn _out2() {
    let p1 = Person {
        name: "Menfusu",
        email: "<EMAIL>",
        year: 1979,
        fullname: "Menfusu PT"
    };

    let mut p2 = p1;
    _ex0(&p1);
    _ex0(&p2);

    _ex(&mut p2);
    _ex0(&p2);
}

pub fn call_util() {
    let x: fdutil::array::heap::HeapList<u32> = fdutil::array::heap::HeapList::new(10);
    println!("{:?}", x);

    let s = fdutil::helper::string::remove_whitespace("Hello word!");
    println!("Len of string ({}) is {}", s, s.len());
}

#[derive(Debug, Clone)]
struct Owner(i32);

impl Owner {
    fn add_one<'a>(&'a mut self) { self.0 += 1; }
    fn print<'a>(&'a self) {
        println!("`print`: {}", self.0);
    }
}

pub fn _out3() {
    let mut owner: Owner = Owner(21);
    owner.add_one();
    owner.print();
    println!("{:?}", owner);

    let mut owner1: Owner = owner.clone();
    owner1.add_one();
    owner1.print();
    println!("{:?}", owner1);
}

fn _verify_intervaltree(tree: &IntervalTree<u32, u32>, i: u32, expected: &[u32]) {
    let mut v1: Vec<_> = tree.query_point(i).map(|x| x.value).collect();
    v1.sort();
    let mut v2: Vec<_> = tree.query(i..(i+1)).map(|x| x.value).collect();
    v2.sort();
    println!("{:?}", v1);
    println!("{:?}", v2);
    println!("{:?}", expected);
}

pub fn _test_intervaltree() {
    let tree: IntervalTree<u32, u32> = [
        (0..3, 1),
        (1..4, 2),
        (2..5, 3),
        (3..6, 4),
        (4..7, 5),
        (5..8, 6),
        (4..5, 7),
        (2..7


-box-left .icon-wrapper{margin:0 10px 0 0}.mfn-header-tmpl .mfn-icon-box-right .icon-wrapper{margin:0 0 0 10px}.mfn-header-tmpl .mfn-icon-box-top .icon-wrapper{margin:0 0 5px}.mfn-header-tmpl .mfn-icon-box-bottom .icon-wrapper{margin:5px 0 0}.column_header_burger.mfn-item-inline .icon-wrapper,.column_header_icon.mfn-item-inline .icon-wrapper{width:auto}@media(max-width:959px){.mfn-header-tmpl .mfn-icon-box-tablet-left .icon-wrapper{margin:0 10px 0 0}.mfn-header-tmpl .mfn-icon-box-tablet-right .icon-wrapper{margin:0 0 0 10px}.mfn-header-tmpl .mfn-icon-box-tablet-top .icon-wrapper{margin:0 0 5px}.mfn-header-tmpl .mfn-icon-box-tablet-bottom .icon-wrapper{margin:5px 0 0}}@media(max-width:767px){.mfn-header-tmpl .mfn-icon-box-mobile-left .icon-wrapper{margin:0 10px 0 0}.mfn-header-tmpl .mfn-icon-box-mobile-right .icon-wrapper{margin:0 0 0 10px}.mfn-header-tmpl .mfn-icon-box-mobile-top .icon-wrapper{margin:0 0 5px}.mfn-header-tmpl .mfn-icon-box-mobile-bottom .icon-wrapper{margin:5px 0 0}}.mfn-header-tmpl .mfn-icon-box-empty-desc .icon-wrapper{margin:0}.mfn-megamenu-tmpl-builder{--mfn-column-gap-left:12px;--mfn-column-gap-right:12px;--mfn-megamenu-menu-gap:0px;--mfn-megamenu-menu-icon-gap:5px;--mfn-megamenu-menu-submenu-icon-gap:10px;--mfn-megamenu-menu-sep:rgba(1,7,39,0.15);--mfn-megamenu-menu-animation-height:3px;--mfn-megamenu-menu-icon-size:25px;--mfn-megamenu-submenu-icon-size:13px;--mfn-megamenu-menu-animation-color:#0089f7;--mfn-column-gap-bottom:10px;--mfn-megamenu-submenu-border-radius-top:4px;--mfn-megamenu-submenu-border-radius-right:4px;--mfn-megamenu-submenu-border-radius-bottom:4px;--mfn-megamenu-submenu-border-radius-left:4px}.mfn-menu-item-megamenu{position:absolute;top:100%}.mfn-megamenu-full-width,.mfn-megamenu-grid{width:100vw}.mfn-megamenu-full-width .container{max-width:100%}.mfn-megamenu-custom-width{width:220px}.mfn-megamenu-pos-left{left:0}.mfn-megamenu-pos-right{right:0;left:auto}.mfn-menu-item-has-megamenu .mfn-menu-item-megamenu{display:none}.mfn-menu-submenu-on-click .mfn-menu-item-has-megamenu.mfn-li-hover>.mfn-menu-item-megamenu,.mfn-menu-submenu-on-hover .mfn-menu-item-has-megamenu:hover>.mfn-menu-item-megamenu.mfn-megamenu-grid.mfn-mm-grid-set,.mfn-menu-submenu-on-hover .mfn-menu-item-has-megamenu:hover>.mfn-menu-item-megamenu:not(.mfn-megamenu-grid){display:block}@media only screen and (max-width


MQ==&mid=2651206987&idx=1&sn=de2cb56d4944508a173973d5c76650bb&subscene=0)
- dotNet安全矩阵
  - [.NET 高级代码审计：一种绕过 GZip 叠加 BinaryFormatter 实现反序列化漏洞的技术](https://mp.weixin.qq.com/s?__biz=MzUyOTc3NTQ5MA==&mid=2247499411&idx=1&sn=8a364bf1a8c8e5bce124f6e526ab39dd&subscene=0)
  - [.NET 内网攻防实战电子报刊](https://mp.weixin.qq.com/s?__biz=MzUyOTc3NTQ5MA==&mid=2247499411&idx=2&sn=e42c077723e8454052476aa2ecd88db1&subscene=0)
  - [.NET 一站式上传 web.config， 绕过多重策略限制并注入哥斯拉 WebShell](https://mp.weixin.qq.com/s?__biz=MzUyOTc3NTQ5MA==&mid=2247499411&idx=3&sn=838aeb9601ba78edf1b31a6ef418e883&subscene=0)
- 知道创宇404实验室
  - [威胁情报 | 攻击再升级，DarkHotel 组织最新 RPC 攻击组件披露](https://mp.weixin.qq.com/s?__biz=MzAxNDY2MTQ2OQ==&mid=2650990872&idx=1&sn=b6ee84a2784db133d2d9a652e2fcdf8e&subscene=0)
- 数世咨询
  - [从加速创新到埋下隐患：无代码/低代码背后的安全挑战](https://mp.weixin.qq.com/s?__biz=MzkxNzA3MTgyNg==&mid=2247538416&idx=1&sn=9d611661ad92de2c7be27fbabf41ce7b&subscene=0)
  - [关于公开征求《中华人民共和国网络安全法（修正草案再次征求意见稿）》意见的通知](https://mp.weixin.qq.com/s?__biz=MzkxNzA3MTgyNg==&mid=2247538416&idx=2&sn=758cadd44b328b2c796573b629e405d6&subscene=0)
- 安全内参
  - [知名工业制造上市公司遭勒索攻击，生产运营被迫中断](https://mp.weixin.qq.com/s?__biz=MzI4NDY2MDMwMw==&mid=2247514159&idx=1&sn=77e7ce7d738f9b88b18e1d47c0b86c60&subscene=0)
  - [这个带路国家社保基金遭网络攻击，大量敏感数据泄露](https://mp.weixin.qq.com/s?__biz=MzI4NDY2MDMwMw==&mid=2247514159&idx=2&sn=c54ad48a9be24f92620f56ea52176baa&subscene=0)
- Viola后花园


0]],[Ue.URL,["#d75fd7",170]],[Ue.ADDED,["#5faf00",70]],[Ue.REMOVED,["#d70000",160]],[Ue.CODE,["#87afff",111]],[Ue.SIZE,["#ffd700",220]]]),ms=r=>r,Wy={[Ue.NUMBER]:ms({pretty:(r,e)=>Qn(r,`${e}`,Ue.NUMBER),json:r=>r}),[Ue.IDENT]:ms({pretty:(r,e)=>Ai(r,e),json:r=>Mt(r)}),[Ue.LOCATOR]:ms({pretty:(r,e)=>mt(r,e),json:r=>Es(r)}),[Ue.DESCRIPTOR]:ms({pretty:(r,e)=>tr(r,e),json:r=>Sn(r)}),[Ue.RESOLUTION]:ms({pretty:(r,{descriptor:e,locator:t})=>iP(r,e,t),json:({descriptor:r,locator:e})=>({descriptor:Sn(r),locator:e!==null?Es(e):null})}),[Ue.DEPENDENT]:ms({pretty:(r,{locator:e,descriptor:t})=>nP(r,e,t),json:({locator:r,descriptor:e})=>({locator:Es(r),descriptor:Sn(e)})}),[Ue.PACKAGE_EXTENSION]:ms({pretty:(r,e)=>{switch(e.type){case"Dependency":return`${Ai(r,e.parentDescriptor)} \u27A4 ${Qn(r,"dependencies",Ue.CODE)} \u27A4 ${Ai(r,e.descriptor)}`;case"PeerDependency":return`${Ai(r,e.parentDescriptor)} \u27A4 ${Qn(r,"peerDependencies",Ue.CODE)} \u27A4 ${Ai(r,e.descriptor)}`;case"PeerDependencyMeta":return`${Ai(r,e.parentDescriptor)} \u27A4 ${Qn(r,"peerDependenciesMeta",Ue.CODE)} \u27A4 ${Ai(r,tn(e.selector))} \u27A4 ${Qn(r,e.key,Ue.CODE)}`;default:throw new Error(`Assertion failed: Unsupported package extension type: ${e.type}`)}},json:r=>{switch(r.type){case"Dependency":return`${Mt(r.parentDescriptor)} > ${Mt(r.descriptor)}`;case"PeerDependency":return`${Mt(r.parentDescriptor)} >> ${Mt(r.descriptor)}`;case"PeerDependencyMeta":return`${Mt(r.parentDescriptor)} >> ${r.selector} / ${r.key}`;default:throw new Error(`Assertion failed: Unsupported package extension type: ${r.type}`)}}}),[Ue.SETTING]:ms({pretty:(r,e)=>(r.get(e),If(r,Qn(r,e,Ue.CODE),`https://yarnpkg.com/configuration/yarnrc#${e}`)),json:r=>r}),[Ue.DURATION]:ms({pretty:(r,e)=>{if(e>1e3*60){let t=Math.floor(e/1e3/60),i=Math.ceil((e-t*60*1e3)/1e3);return i===0?`${t}m`:`${t}m ${i}s`}else{let t=Math.floor(e/1e3),i=e-t*1e3;return i===0?`${t}s`:`${t}s ${i}ms`}},json:r=>r}),[Ue.SIZE]:ms({pretty:(r,e)=>{let t=["KB","MB","GB","TB"],i=t.length;for(;i>1&&e<1024**i;)i-=1;let n=1024**i,s=Math.floor(e*100/n)/100;return Qn(r,`${s} ${t[i-1]}`,Ue.NUMBER)},json:r=>r}),[Ue.PATH]:ms({pretty:(r,e)=>Qn(r,K.from


import datetime

from s3p_sdk.plugin.config import (
    PluginConfig,
    CoreConfig,
    TaskConfig,
    trigger,
    MiddlewareConfig,
    modules,
    payload,
    RestrictionsConfig,
)
from s3p_sdk.plugin.types import SOURCE
from s3p_sdk.module import (
    WebDriver,
)

config = PluginConfig(
    plugin=CoreConfig(
        reference='openid',         # уникальное имя источника
        type=SOURCE,                            # Тип источника (SOURCE, ML, PIPELINE)
        files=['openid.py', ],        # Список файлов, которые будут использоваться в плагине (эти файлы будут сохраняться в платформе)
        is_localstorage=False,
        restrictions=RestrictionsConfig(
            maximum_materials=None,
            to_last_material=None,
            from_date=datetime.datetime(2024, 8, 1),
            to_date=None,
        ),
    ),
    task=TaskConfig(
        trigger=trigger.TriggerConfig(
            type=trigger.SCHEDULE,
            interval=datetime.timedelta(days=1),    # Интервал перезапуска плагина
        )
    ),
    middleware=MiddlewareConfig(
        modules=[
            modules.TimezoneSafeControlConfig(order=1, is_critical=True),
            modules.SaveOnlyNewDocuments(order=2, is_critical=True),
        ],
        bus=None,
    ),
    payload=payload.PayloadConfig(
        file='openid.py',                 # python файл плагина (точка входа). Этот файл должен быть указан в `plugin.files[*]`
        classname='OpenID',               # имя python класса в указанном файле
        entry=payload.entry.EntryConfig(
            method='content',
            params=[
                payload.entry.ModuleParamConfig(key='web_driver', module_name=WebDriver, bus=True),
            ]
        )
    )
)

__all__ = ['config']


 rdev, ve, num, prim );

          /* Prepare Cr plane */
          radeon_waitfifo( rdrv, rdev, s420 ? 3 : 2 );
          radeon_out32( mmio, RB3D_COLOROFFSET, rdev->dst_offset_cr );
          if (s420)
               radeon_out32( mmio, PP_TXOFFSET_0, rdev->src_offset_cr );
          radeon_out32( mmio, PP_TFACTOR_0, rdev->cr_cop );

          /* Map Cr plane */
          r100DoTextureTriangles( rdrv, rdev, ve, num, prim );

          /* Reset */
          radeon_waitfifo( rdrv, rdev, s420 ? 8 : 5 );
          radeon_out32( mmio, RB3D_COLOROFFSET, rdev->dst_offset );
          radeon_out32( mmio, RB3D_COLORPITCH, rdev->dst_pitch );
          if (s420) {
               radeon_out32( mmio, PP_TEX_SIZE_0, ((rdev->src_height-1) << 16) |
                                                  ((rdev->src_width-1) & 0xffff) );
               radeon_out32( mmio, PP_TEX_PITCH_0, rdev->src_pitch - 32 );
               radeon_out32( mmio, PP_TXOFFSET_0, rdev->src_offset );
          }
          radeon_out32( mmio, RE_TOP_LEFT, (clip->y1 << 16) |
                                           (clip->x1 & 0xffff) );
          radeon_out32( mmio, RE_BOTTOM_RIGHT, (clip->y2 << 16) |
                                               (clip->x2 & 0xffff) );
          radeon_out32( mmio, PP_TFACTOR_0, rdev->y_cop );
     }

     return true;
}

void r100EmitCommands3D( void *drv, void *dev )
{
     RadeonDriverData *rdrv = (RadeonDriverData*) drv;
     RadeonDeviceData *rdev = (RadeonDeviceData*) dev;

     if (rdev->vb_count)
          r100_flush_vb( rdrv, rdev );
}


一些。

- A17527: 早九点到晚九点

- A17929: 早9:00-晚9:30
晚9:25阿姨会敲澡堂单间门喊你快点出来，冲地板的时候水有可能顺着门缝滋到你
据此可得，如果轮到你扫地粘头发/擦窗台黑板讲台门/拖地了你晚上就洗不了澡\~

- A18272: 早没注意，晚21:30

- A19773: 7:00-22:00

- A20702: .

- A21819: 澡堂是7：00-22：00好像

- A23558: 早六点到晚十点

- A23759: 澡堂最晚到十点

- A26183: 到晚上九点半

- A28394: 7:00-23:00

## Q: 校园内可以骑电瓶车吗，电池在哪能充电？

- A16887: 可以。充电应该在食堂吧（不太清楚）

- A17527: 可以骑电动车，有付费充电桩

- A17929: 是这样的，五月份有个哥们骑电动紧急避开路人导致自己腿跌破了。他女朋友找那位路人对线要求医药费自己三路人七分，威胁告到学院，还找警察评理。遂事情闹大了滨海校内就暂时不给骑了。
细想:校内毕竟没有斑马线没有人行道没有停车场，进城主要靠校内公交。路人赶错过要再等两小时左右的路边校车走快了，电动车也没有划定行驶区域避让不及，都事出有因，责任还真不好划。

- A18272: 松山有充电桩，有时候缺德的人会把别人插头拔了插自己的。滨海前段时间发调查问卷在征集，不知道现在怎么样了。

- A19773: 可以骑电瓶车，充电口很少，好像是在食堂那里？

- A20702: .

- A21819: 可以，我们这楼下有充电桩

- A23558: 可以

- A23759: 可以，不清楚

- A26183: 不清楚

- A28394: 可以,在食堂充电

## Q: 宿舍限电情况？

- A16887: 大功率原则上都不能用，偷偷用吧。注意查寝时不要被抓到


("truetype"), url("../webfonts/fa-brands-400.svg#fontawesome") format("svg"); }

.fab {
  font-family: 'Font Awesome 5 Brands';
  font-weight: 400; }
@font-face {
  font-family: 'Font Awesome 5 Free';
  font-style: normal;
  font-weight: 400;
  font-display: block;
  src: url("../webfonts/fa-regular-400.eot");
  src: url("../webfonts/fa-regular-400.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-regular-400.woff2") format("woff2"), url("../webfonts/fa-regular-400.woff") format("woff"), url("../webfonts/fa-regular-400.ttf") format("truetype"), url("../webfonts/fa-regular-400.svg#fontawesome") format("svg"); }

.far {
  font-family: 'Font Awesome 5 Free';
  font-weight: 400; }
@font-face {
  font-family: 'Font Awesome 5 Free';
  font-style: normal;
  font-weight: 900;
  font-display: block;
  src: url("../webfonts/fa-solid-900.eot");
  src: url("../webfonts/fa-solid-900.eot?#iefix") format("embedded-opentype"), url("../webfonts/fa-solid-900.woff2") format("woff2"), url("../webfonts/fa-solid-900.woff") format("woff"), url("../webfonts/fa-solid-900.ttf") format("truetype"), url("../webfonts/fa-solid-900.svg#fontawesome") format("svg"); }

.fa,
.fas {
  font-family: 'Font Awesome 5 Free';
  font-weight: 900; }
.tax-class {
    margin-bottom: 40px;
}

.tax-rates {
    .form-group {
        margin-bottom: 0;
    }

    .tax-name {
        min-width: 180px;
    }

    .country,
    .state {
        min-width: 150px;
    }

    .country select,
    .state select {
        width: 100%;
    }

    .city,
    .zip,
    .rate {
        min-width: 120px;
    }
}
html {
    -ms-text-size-adjust: 100%;
    -webkit-text-size-adjust: 100%;
    -webkit-print-color-adjust: exact;
}

body {
    font-family: 'Open Sans', sans-serif;
    font-size: 15px;
    min-width: 350px;
    margin: 0;
}

h1, h2, h3, h4, h5, h6, ul, li, p {
    margin: 0;
    padding: 0;
    color: #444444;
}

h1 {
    font-size: 36px;
    line-height: 44px;
}

h2 {
    font-size: 30px;
    line-height: 36px;
}

h3 {
    font-size: 24px;
    line-height: 29px;
}

h4 {
    font-size: 21px;
    line-height: 26px;
}

h5 {
    font-size: 18px;
    line-height: 22px;
}

h6 {
    font-size: 16px;
    line-height: 20px;
}

p {
    font-size: 16px;
    line-height: 22px;
}

label {
    font-weight: 600;
    font-size: 16px;
}

span {
    font-size: 16px;
}

table {
    border-collapse: collapse;
    border-spacing: 0;
    background-color: transparent;
}

td, th {
    padding: 0;
}

* {
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;


;                            \
    table[locktag##sep##drdpa] = expand(drdpa);                                \
  }

#if KMP_USE_ADAPTIVE_LOCKS
#define fill_table(table, expand)                                              \
  {                                                                            \
    fill_jumps(table, expand, _);                                              \
    table[locktag_adaptive] = expand(queuing);                                 \
    fill_jumps(table, expand, _nested_);                                       \
  }
#else
#define fill_table(table, expand)                                              \
  {                                                                            \
    fill_jumps(table, expand, _);                                              \
    fill_jumps(table, expand, _nested_);                                       \
  }
#endif // KMP_USE_ADAPTIVE_LOCKS

#define expand(l)                                                              \
  (void (*)(kmp_user_lock_p, const ident_t *)) __kmp_set_##l##_lock_location
  fill_table(__kmp_indirect_set_location, expand);
#undef expand
#define expand(l)                                                              \
  (void (*)(kmp_user_lock_p, kmp_lock_flags_t)) __kmp_set_##l##_lock_flags
  fill_table(__kmp_indirect_set_flags, expand);
#undef expand
#define expand(l)                                                              \
  (const ident_t *(*)(kmp_user_lock_p)) __kmp_get_##l##_lock_location
  fill_table(__kmp_indirect_get_location, expand);
#undef expand
#define expand(l)                                                              \
  (kmp_lock_flags_t(*)(kmp_user_lock_p)) __kmp_get_##l##_lock_flags
  fill_table(__kmp_indirect_get_flags, expand);
#undef expand

  __kmp_init_user_locks = TRUE;
}

// Clean up the lock table.
void __kmp_cleanup_indirect_user_locks() {
  int k;

  // Clean up locks in the pools first (they were already destroyed before going
  // into the pools).
  for (k = 0; k < KMP_NUM_I_LOCKS; ++k) {
    kmp_indirect_lock_t *l = __kmp_indirect_lock_pool[k];
    while (l != NULL) {
      kmp_indirect_lock_t *ll = l;
      l = (kmp_indirect_lock_t *)l->lock->pool.next;
      KA_TRACE(20, ("__kmp_cleanup_indirect_user_locks: freeing %p from pool\n",
                    ll));
      __kmp_free(ll->lock);
      ll->lock = NULL;
    }
    __kmp_indirect_lock_pool[k] = NULL;
  }
  // Clean up the remaining undestroyed locks.
  kmp_indirect_lock_table_t *ptr = &__kmp_i_lock_table;
  while (ptr) {
    for (kmp_uint32 row = 0; row < ptr->nrow_ptrs; ++row) {
      if (!ptr->table[row])
        continue;
      for (kmp_uint32 col = 0; col < KMP_I_LOCK_CHUNK; ++col) {
        kmp_indirect_lock_t *l = &ptr->table[row][col];
        if (l->lock) {
          // Locks not destroyed explicitly need to be destroyed here.
          KMP_I_LOCK_FUNC(l, destroy)(


((runOnlyVisibleInScreen && !isVisible) || isDead) {
      return;
    }

    seePlayer(
      radiusVision: radiusVision,
      observed: (player) {
        final radAngle = getAngleToPlayer();

        final playerRect = player.rectCollision;
        final rectPlayerCollision = Rect.fromLTWH(
          playerRect.left - margin,
          playerRect.top - margin,
          playerRect.width + (margin * 2),
          playerRect.height + (margin * 2),
        );

        if (rectCollision.overlaps(rectPlayerCollision)) {
          closePlayer(player);
          stopMove();
          return;
        }

        moveFromAngle(radAngle);
      },
      notObserved: () {
        final stop = notObserved?.call() ?? true;
        if (stop) {
          stopMove();
        }
      },
    );
  }
}
import 'package:flutter/services.dart';

class KeyboardDirectionalKeys {
  final LogicalKeyboardKey up;
  final LogicalKeyboardKey down;
  final LogicalKeyboardKey left;
  final LogicalKeyboardKey right;

  KeyboardDirectionalKeys({
    required this.up,
    required this.down,
    required this.left,
    required this.right,
  });

  List<LogicalKeyboardKey> get keys => [up, down, left, right];

  bool contain(LogicalKeyboardKey key) => keys.contains(key);

  factory KeyboardDirectionalKeys.arrows() {
    return KeyboardDirectionalKeys(
      down: LogicalKeyboardKey.arrowDown,
      up: LogicalKeyboardKey.arrowUp,
      left: LogicalKeyboardKey.arrowLeft,
      right: LogicalKeyboardKey.arrowRight,
    );
  }

  factory KeyboardDirectionalKeys.wasd() {
    return KeyboardDirectionalKeys(
      down: LogicalKeyboardKey.keyS,
      up: LogicalKeyboardKey.keyW,
      left: LogicalKeyboardKey.keyA,
      right: LogicalKeyboardKey.keyD,
    );
  }
}

class KeyboardConfig {
  /// Use to enable ou disable keyboard events
  bool enable;

  /// Type of the directional (arrows, wasd or wasdAndArrows)
  final List<KeyboardDirectionalKeys> directionalKeys;

  /// You can pass specific Keys accepted. If null accept all keys
  final List<LogicalKeyboardKey>? acceptedKeys;

  /// Use to enable diagonal input events
  bool enableDiagonalInput;

  KeyboardConfig({
    this.enable = true,
    List<KeyboardDirectionalKeys>? directionalKeys,
    this.acceptedKeys,
    this.enableDiagonalInput = true,
  }) : directionalKeys = directionalKeys ?? [KeyboardDirectionalKeys.arrows()] {
    acceptedKeys?.addAll(
      this.directionalKeys.map((e) => e.keys).expand((e) => e),
    );
  }
}
import 'dart:math';

import 'package:bonfire/bonfire.dart';
import 'package:flutter/gestures.dart';

class FingerPoint {
  final int id;
  final Vector2 position;
  late Vector2 _initialPosition;
  Vector2 get initialPosition => _initialPosition;
  FingerPoint({
    required this.id,
    required this.position,
  }) {
    _initialPosition = position.clone();
  }
}

mixin PinchGesture on GameComponent {
  final List<FingerPoint> _fingers = [];
  bool _startPinch = false;

  @override
  bool handlerPointerDown(PointerDownEvent event) {
    final gEvent = GestureEvent.fromPointerEvent(
      event,
      screenToWorld: gameRef.screenToWorld,
      globalToViewportPosition: gameRef.globalToViewportPosition,


			return false;
		}
		return super.hit(x, y, hitThreshold);
	}

	@Override
	protected void updateAlgos() {
		if (bernsteinBasedPlotter) {
			return;
		}
		implicitCurve.getLocus();
	}
}
/*
GeoGebra - Dynamic Mathematics for Everyone
http://www.geogebra.org

This file is part of GeoGebra.

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation.

 */

package org.geogebra.common.euclidian.draw;

import org.geogebra.common.awt.GColor;
import org.geogebra.common.awt.GFont;
import org.geogebra.common.awt.GGraphics2D;
import org.geogebra.common.awt.GRectangle;
import org.geogebra.common.euclidian.Drawable;
import org.geogebra.common.euclidian.EuclidianView;
import org.geogebra.common.kernel.geos.GeoText;
import org.geogebra.common.kernel.kernelND.GeoPointND;
import org.geogebra.common.kernel.matrix.Coords;
import org.geogebra.common.main.App;
import org.geogebra.common.util.DoubleUtil;

/**
 * Drawable representation of text
 *
 * @author Markus
 */
public final class DrawText extends Drawable {

	/**
	 * minimum height of width
	 */
	public static final int MIN_EDITOR_WIDTH = 100;
	/**
	 * minimum height of editor
	 */
	public static final int MIN_EDITOR_HEIGHT = 20;

	public static final int DEFAULT_MARGIN = 3;
	private final AlignDrawText alignment;

	private GeoText text;
	private boolean isVisible;
	private boolean isLaTeX;
	private int fontSize = -1;
	private int fontStyle = -1;
	private boolean serifFont;
	private GFont textFont;

	// private Image eqnImage;
	private int oldXpos;
	private int oldYpos;
	private boolean needsBoundingBoxOld;

	/**
	 * Creates new DrawText
	 *
	 * @param view
	 *            view
	 * @param text
	 *            text
	 */
	public DrawText(EuclidianView view, GeoText text) {
		this.view = view;
		this.text = text;
		geo = text;

		textFont = view.getApplication().getPlainFontCommon()
				.deriveFont(GFont.PLAIN, view.getFontSize());
		alignment = new AlignDrawText(text, this);
		// this is needed as (bold) LaTeX texts are created with isLaTeX = false
		// at this stage
		updateStrokes(text);

		update();
	}

	@Override
	public void update() {
		isVisible = geo.isEuclidianVisible();
		if (!isVisible && !text.needsUpdatedBoundingBox()) {
			// Corner[Element[text
			return;
		}

		if (isLaTeX) {
			updateStrokes(text);
		}

		String newText = text.getTextString();

		final boolean textChanged = labelDesc == null || !labelDesc.equals(newText)
				|| isLaTeX != text.isLaTeX()
				|| text.needsUpdatedBoundingBox() != needsBoundingBoxOld;
		labelDesc = newText;
		isLaTeX = text.isLaTeX();
		needsBoundingBoxOld = text.needsUpdatedBoundingBox();

		// compute location of text
		updateLabelPosition();

		boolean positionChanged = xLabel != oldXpos || yLabel != oldYpos
				|| alignment.hasChanged();
		oldXpos = xLabel;
		oldYpos = yLabel;
		alignment.update();
		boolean fontChanged = doUpdateFontSize();

		// some commented code for LaTeX speedup removed in r22321

		// We need check for null bounding


.ofType_params[0]
        }`;
      });

    const listFields = this.node.fields
      .filter((f: any) => f.ofType && f.ofType === "List")
      .filter((field: any) => baseTypes.indexOf(field.ofType_params[0]) === -1)
      .map((field: any) => {
        let min = field.restrictions.find(a => a.key === "min") || { value: 0 };
        let max = field.restrictions.find(a => a.key === "max");
        return `${field.ofType_params[0]} "${min.value}..${max ? max.value : "*"}" --> "1" ${
          this.node.id
        } : List ${field.ofType_params[0]}`;
      });

    return [...normalFields, ...maybeFields, ...listFields].join("\n");
  }

  extensions() {
    return this.node.extends
      .filter((extension: any) => this.lookup.types.indexOf(extension) > -1)
      .map((extension: any) => `${extension} <|-- ${this.node.id}`)
      .join("\n");
  }

  source() {
    return this.node.extends.length > 0 ? `<${this.node.extends.join(",")}>` : "";
    //return this.node.source ? `<${this.node.source}>` : "";
  }

  annotations() {
    if (this.node.annotations.length === 0) return "";
    const annotations = this.node.annotations
      .map(a => foldText(`<b>${a.key}</b>: ${a.value}`))
      .join("\n");
    return `
===
  ${annotations}
    `.trim();
  }

  params() {
    return this.node.params ? " " + this.node.params.join(" ") : "";
  }

  template() {
    if (this.node.params && this.node.params.length > 0) {
      return "<< (T,orchid) >>";
    } else {
      return "";
    }
  }

  toString(): string {
    return `
class "${this.node.id}${this.params()}" as ${this.node.id} ${this.source()}${this.template()} {
${this.fields()}
${this.annotations()}
}
${this.associations()}
${this.extensions()}
${this.node.source ? `${this.node.source} *-- ${this.node.id}: ALIAS` : ""}
`
      .trim()
      .replace(/\n\n+/g, "\n");
  }
}
import Command from "../structures/Command";
import Base from "../Base";
import fetch from "node-fetch";

export default <Command>{
    name: "bans",
    description: "Shows the most recent bans on Wiimmfi",
    args: [{
        name: "limit",
        description: "How many bans to fetch",
        required: false
    }],
    guildOnly: false,
    category: "mkw",
    ownerOnly: false,
    run: (base: Base, message: any, texts: any) => {
        return new Promise(async (a: any, b: any) => {
            const args: string[] = message.content.split(" ").slice(2);
            const limit: number = parseInt(args[0]) || 5;
            if (limit >= 10)
                return b(texts.mkw_ban_limit);

            const request = await fetch("https://wiimmfi.glitch.me/bans?limit=" + limit).then(r => r.json());

            a([{
                embed: {
                    title: texts.mkw_recent_bans,
                    fields: request.map((res: any) => {
                        return {
                            name: res.name || "Unknown name",
                            value: texts.mkw_ban_structure
                                .replace(/{reason}/g, res.reason
                                    .replace(/\n/g, ""))
                                .replace(/{ban_id}/g, res.ban_id


认证密码
		 */
		private String password;
	}

	@Getter
	@Setter
	public static class McpServer {
		/**
		 * 是否启用，默认：关闭
		 */
		private boolean enable = false;
		/**
		 * sse 端点
		 */
		private String sseEndpoint;
		/**
		 * message 端点
		 */
		private String messageEndpoint;
	}
}
/*
 * Copyright (c) 2019-2029, Dreamlu 卢春梦 (596392912@qq.com & dreamlu.net).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.dromara.mica.mqtt.spring.client;

import lombok.Getter;
import org.dromara.mica.mqtt.codec.message.builder.MqttPublishBuilder;
import org.dromara.mica.mqtt.codec.properties.MqttProperties;
import org.dromara.mica.mqtt.codec.MqttQoS;
import org.dromara.mica.mqtt.core.client.*;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.Ordered;
import org.tio.client.ClientChannelContext;
import org.tio.client.TioClient;
import org.tio.client.TioClientConfig;
import org.tio.utils.timer.TimerTask;

import java.util.List;
import java.util.concurrent.Executor;
import java.util.function.Consumer;

/**
 * mqtt client 模板
 *
 * @author wsq（冷月宫主）
 * @author ChangJin Wei (魏昌进)
 */
public class MqttClientTemplate implements ApplicationContextAware, SmartInitializingSingleton, InitializingBean, DisposableBean, Ordered, IMqttClient {
	public static final String DEFAULT_CLIENT_TEMPLATE_BEAN = "mqttClientTemplate";
	@Getter
	private final MqttClientCreator clientCreator;
	private ApplicationContext applicationContext;
	private MqttClient client;

	public MqttClientTemplate(MqttClientCreator clientCreator) {
		this.clientCreator = clientCreator;
	}

	/**
	 * 订阅
	 *
	 * @param topicFilter topicFilter
	 * @param listener    MqttMessageListener
	 * @return MqttClient
	 */
	public MqttClient subQos0(String topicFilter, IMqttClientMessageListener listener) {
		return client.subscribe(topicFilter, MqttQoS.QOS0, listener);
	}

	/**
	 * 订阅
	 *
	 * @param topicFilter topicFilter
	 * @param listener    MqttMessageListener
	 * @return MqttClient
	 */
	public MqttClient subQos1(String topicFilter, IMqttClientMessageListener listener) {
		return client.subscribe(topicFilter, MqttQoS.QOS1, listener);
	}

	/**
	 * 订阅
	 *
	 * @param topicFilter topicFilter
	 * @param listener    Mq


;
    }
    if (f2 < 0) {
      f2 = PI * 2 + f2;
    }

    if (sweep_flag && f1 > f2) {
      f1 = f1 - PI * 2;
    }
    if (!sweep_flag && f2 > f1) {
      f2 = f2 - PI * 2;
    }
  } else {
    f1 = recursive[0];
    f2 = recursive[1];
    cx = recursive[2];
    cy = recursive[3];
  }
  let df = f2 - f1;
  if (Math.abs(df) > _120) {
    const f2old = f2,
      x2old = x2,
      y2old = y2;
    f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
    x2 = cx + rx * Math.cos(f2);
    y2 = cy + ry * Math.sin(f2);
    res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [
      f2,
      f2old,
      cx,
      cy
    ]);
  }
  df = f2 - f1;
  const c1 = Math.cos(f1),
    s1 = Math.sin(f1),
    c2 = Math.cos(f2),
    s2 = Math.sin(f2),
    t = Math.tan(df / 4),
    hx = 4 / 3 * rx * t,
    hy = 4 / 3 * ry * t,
    m1 = [x1, y1],
    m2 = [x1 + hx * s1, y1 - hy * c1],
    m3 = [x2 + hx * s2, y2 - hy * c2],
    m4 = [x2, y2];
  m2[0] = 2 * m1[0] - m2[0];
  m2[1] = 2 * m1[1] - m2[1];
  if (recursive) {
    return [m2, m3, m4].concat(res);
  } else {
    res = [m2, m3, m4]
      .concat(res)
      .join()
      .split(',');
    const newres = [];
    for (let i = 0, ii = res.length; i < ii; i++) {
      newres[i] =
        i % 2
          ? rotate(res[i - 1], res[i], rad).y
          : rotate(res[i], res[i + 1], rad).x;
    }
    return newres;
  }
}

// http://schepers.cc/getting-to-the-point
function catmullRom2bezier(crp, z) {
  const d = [];
  for (let i = 0, iLen = crp.length; iLen - 2 * !z > i; i += 2) {
    const p = [
      {
        x: +crp[i - 2],
        y: +crp[i - 1]
      },
      {
        x: +crp[i],
        y: +crp[i + 1]
      },
      {
        x: +crp[i + 2],
        y: +crp[i + 3]
      },
      {
        x: +crp[i + 4],
        y: +crp[i + 5]
      }
    ];
    if (z) {
      if (!i) {
        p[0] = {
          x: +crp[iLen - 2],
          y: +crp[iLen - 1]
        };
      } else if (iLen - 4 === i) {
        p[3] = {
          x: +crp[0],


imeter}")
    println("Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}")
}

// 构造函数有1个不可变属性，
abstract class Shape(val sides: List<Double>) {
    // 泛型使用尖括号，与Java相同
    val perimeter: Double get() = sides.sum() // 除了构造函数类还可以定义成员变量，也可以定义抽象的方法，但是kotlin的抽象类的抽象方法要使用abstract修饰

    abstract fun calculateArea(): Double
}

interface RectangleProperties {
    // 接口方法不用abstract修饰
    val isSquare: Boolean
}

class Rectangle(
    // 构造函数有2个可变属性，
    var height: Double,
    var length: Double
) : RectangleProperties, Shape(listOf(height, length, height, length)) {
    // 继承使用: 逗号隔开，只允许一个抽象类，JVM平台目前Java Scala Kotlin等都不支持多继承（类）
    override val isSquare: Boolean get() = length == height

    override fun calculateArea(): Double = height * length
}

class Triangle(
    var sideA: Double,
    var sideB: Double,
    var sideC: Double
) : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double {
        val s = perimeter / 2
        return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
    }
}
package com.example.c001apk.ui.activity.topic

import android.os.Bundle
import androidx.fragment.app.FragmentTransaction
import com.example.c001apk.R
import com.example.c001apk.databinding.ActivityTopicBinding
import com.example.c001apk.ui.activity.BaseActivity
import com.example.c001apk.ui.fragment.topic.TopicFragment

class TopicActivity : BaseActivity() {

    private lateinit var binding: ActivityTopicBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityTopicBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val title = intent.getStringExtra("title")!!

        if (supportFragmentManager.findFragmentById(R.id.topicFragment) == null) {
            supportFragmentManager
                .beginTransaction()
                .replace(R.id.topicFragment, TopicFragment.newInstance(title, ""))
                .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN)
                .commit()
        }
    }

}package com.example.c001apk.ui.fragment.search

import android.annotation.SuppressLint
import android.content.ContentValues
import android.content.Context
import android.database.sqlite.SQLiteDatabase
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import android.view.inputmethod.InputMethodManager
import android.widget.TextView
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import androidx.lifecycle.ViewModelProvider
import com.example.c001apk.R
import com.example.c001apk.databinding.FragmentSearchBinding
import com.example.c001apk.ui.fragment.search.history.HistoryAdapter
import com.example.c001apk.ui.fragment.search.history.HistoryDataBaseHelper
import com.example.c001apk.ui.fragment.search.history.HistoryViewModel
import com.example.c001apk.ui.fragment.search.history.IOnItemClickListener
import com.example.c001apk.ui.fragment.search.result.SearchResultFragment
import com.google.android.flexbox.FlexDirection
import com.google.android.flexbox.FlexWrap
import com.google.android.flexbox.FlexboxLayoutManager
import com.google.android.material.dialog.MaterialAlertDialogBuilder

class SearchFragment : Fragment(), IOnItemClickListener {

    private lateinit var binding: FragmentSearchBinding
    private val viewModel by lazy { ViewModelProvider(this)[HistoryViewModel::class.java] }
    private lateinit var dbHelper: HistoryDataBaseHelper
    private l


ero\'yu satın aldıktan sonra nasıl ödeme yapabilirim?';

  @override
  String get faq250Sbquestion8722Sb1057Sbagoradesk => 'Kripto paraları nasıl gönderirim ve satın aldıktan sonra kripto paralarla nasıl ödeme yapabilirim?';

  @override
  String faq250Sbquestion8722Sb11(Object appName) {
    return 'Monero\'yu $appName Cüzdanıma nasıl alabilirim?';
  }

  @override
  String faq250Sbquestion8722Sb1157Sbagoradesk(Object appName) {
    return '$appName Cüzdanıma kripto para birimini nasıl alabilirim?';
  }

  @override
  String faq250Sbquestion8722Sb12(Object appName) {
    return 'Monero\'yu $appName Cüzdanıma göndermek veya almak ne kadar sürer?';
  }

  @override
  String faq250Sbquestion8722Sb1257Sbagoradesk(Object appName) {
    return '$appName Cüzdanıma kripto para birimleri göndermek veya almak ne kadar sürer?';
  }

  @override
  String get faq250Sbquestion8722Sb13 => '60 dakika bekledim ve işlemim hala beklemede, şimdi ne olacak?';

  @override
  String get faq250Sbquestion8722Sb17 => 'Geri bildirim sistemi nasıl çalışır?';

  @override
  String get faq250Sbquestion8722Sb18 => 'Onaylanmış ve onaylanmamış geribildirim arasındaki fark nedir?';

  @override
  String get faq250Sbquestion8722Sb19 => 'Web bildirimlerini nasıl etkinleştiririm?';

  @override
  String get faq250Sbquestion8722Sb2 => 'Dolandırılmaktan nasıl korunurum?';

  @override
  String get faq250Sbquestion8722Sb20 => 'Bir tüccar benden kimliğimi istiyor ve kendimi rahat hissetmiyorum.';

  @override
  String get faq250Sbquestion8722Sb21 => 'Satıcıya ödeme yaptım ancak Monero\'mu henüz almadım.';

  @override
  String get faq250Sbquestion8722Sb2157Sbagoradesk => 'Ödeme yaptım ancak paramı henüz almadım.';

  @override
  String get faq250Sbquestion8722Sb22 => 'Neden cüzdanımdaki tüm Monero\'ları gönderemiyorum?';

  @override
  String get faq250Sbquestion8722Sb2257Sbagoradesk => 'Neden cüzdanımdaki tüm paraları gönderemiyorum?';

  @override
  String faq250Sbquestion8722Sb23(Object appName) {
    return '$appName üzerinden bir işlem yaptım ve alıcı tarafta görünmüyor!';
  }

  @override
  String get faq250Sbquestion8722Sb24 => 'Ödememi yaptım ancak ödedim butonuna basmayı unuttum veya zamanında basmadım';

  @override
  String get faq250Sbquestion8722Sb25 => 'Anlaşmazlıklar nasıl ele alınacak?';

  @override
  String get faq250Sbquestion8722Sb26 => 'Monero\'yu yanlış adrese gönderdim, geri alabilir miyim?';

  @override
  String get faq250Sbquestion8722Sb2657Sbagoradesk => 'Yanlış adrese para gönderdim, geri alabilir miyim?';

  @override
  Stri


, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    //Rollout data
    IDD_COMP_ONESHOT, IDS_COMP_ONESHOTS, 0, 0, nullptr,

    //params
    kOneShotAnimName,  _T("AnimationName"),    TYPE_STRING,    0, 0,
        p_ui,   TYPE_EDITBOX, IDC_COMP_ONESHOT_ANIM_TEXTBOX,
        p_end,

    kPlayBackwardsBool, _T("PlayBackwardsBool"), TYPE_BOOL, 0,  0,
        p_default, FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_ONESHOT_PLAY_BACK_BOOL,
        p_end,

    kControlSpeedBool, _T("ControlSpeedBool"), TYPE_BOOL, 0,    0,
        p_default, FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_ONESHOT_CONT_SPEED_BOOL,
        p_end,

    kSeekTimeFloat, _T("SeekTimeFloat"), TYPE_FLOAT, 0, 0,
        p_default, 1.0f,
        p_ui,   TYPE_SPINNER, EDITTYPE_POS_FLOAT,
        IDC_COMP_ONESHOT_SEEK_FIELD_EDIT, IDC_COMP_ONESHOT_SEEK_FIELD_SPIN, .1f,
        p_end,

    kSmartSeekBool, _T("SmartSeekBool"), TYPE_BOOL, 0,  0,
        p_default, FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_SMART_SEEK,
        p_end,

    kNoSeekBool, _T("NoSeekBool"), TYPE_BOOL, 0,    0,
        p_default, FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_NO_SEEK,
        p_end,

    p_end
);

plOneShotComponent::plOneShotComponent()
{
    fClassDesc = &gOneShotDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

plKey plOneShotComponent::GetOneShotKey(plMaxNode *node)
{
    if (fMods.find(node) != fMods.end())
        return fMods[node]->GetKey();

    return nullptr;
}

bool plOneShotComponent::IsValid()
{
    const MCHAR* animName = fCompPB->GetStr(kOneShotAnimName);
    return (animName && *animName != _M('\0'));
}

bool plOneShotComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
    fMods.clear();

    if (IsValid())
    {
        node->SetForceLocal(true);
        return true;
    }
    else
    {
        if (pErrMsg->Set(true, "One-Shot", ST::format("One-shot component on '{}' has no animation name, and will not be included. Abort this export?", node->GetName())).Ask())
            pErrMsg->Set(true);
        else
            pErrMsg->Set(false); // Don't want to abort
        return false;
    }
}

//
// PreConvert done below
//
bool plOneShotComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    if (IsValid())
    {
        plOneShotMod *mod = new plOneShotMod;
        hsgResMgr::ResMgr()->NewKey(IGetUniqueName(node), mod, node->GetLocation());
        fMods[node] = mod;
    }

    return true;
}

//
// Convert Done below
//
bool plOneShotComponent::Convert(plMaxNode* node, plErrorMsg *pErrMsg)
{
    if (fMods.find(node) != fMods.end())
    {
        const MCHAR* animName = fCompPB->GetStr(kOneShotAnimName);
        bool drivable = fCompPB->GetInt(kControlSpeedBool);
        bool reversable = fCompPB->GetInt(kPlayBackwardsBool);
        float seekDuration = fCompPB->GetFloat(kSeekTimeFloat);
        bool smartSeek = fCompPB->GetInt(kSmartSeekBool);
        bool noSeek = fCompPB->GetInt(kNoSeekBool);

        plOneShotMod *mod = fMods[node];
        mod->Init(animName, drivable, reversable, seekDuration, smartSeek, noSeek);
        node->AddModifier(mod, IGetUniqueName(node));

        return true;
    }

    return false;
}/*==LICENSE==*

CyanWorlds


.

  Watch: Ultralytics YOLO Quick Start Guide

!!! Tip "Совет"

    Требования PyTorch зависят от операционной системы и требований CUDA, поэтому рекомендуется сначала установить PyTorch, следуя инструкциям на [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).

## Использование Ultralytics с CLI

Интерфейс командной строки (CLI) Ultralytics позволяет выполнять простые команды одной строкой без необходимости настройки Python среды. CLI не требует настройки или кода на Python. Все задачи можно легко выполнить из терминала с помощью команды `yolo`. Прочтите [Руководство по CLI](/../usage/cli.md), чтобы узнать больше о использовании YOLOv8 из командной строки.

!!! Example "Пример"

    === "Cинтаксис"

        Команды Ultralytics `yolo` используют следующий синтаксис:
        ```bash
        yolo ЗАДАЧА РЕЖИМ АРГУМЕНТЫ

        Где   ЗАДАЧА (необязательно) одна из [detect, segment, classify]
                РЕЖИМ (обязательно) один из [train, val, predict, export, track]
                АРГУМЕНТЫ (необязательно) любое количество пар 'arg=value', которые переопределяют настройки по умолчанию.
        ```
        Смотрите все АРГУМЕНТЫ в полном [Руководстве по конфигурации](/../usage/cfg.md) или с помощью `yolo cfg`

    === "Train"

        Обучение модели для детекции на 10 эпохах с начальной скоростью обучения 0.01
        ```bash
        yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
        ```

    === "Predict"

        Прогнозирование видео с YouTube с использованием предварительно обученной модели сегментации при размере изображения 320:
        ```bash
        yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
        ```


Context) context.Context {
	// try to get the logger from the wrapped zerologger
	if wrappedLogger, ok := logger.FromContext(ctx).(*wrapZerolog); ok {
		return wrappedLogger.inner.WithContext(ctx)
	}

	// if there's no logger, fall-back to global logger instance
	return log.Logger.WithContext(ctx)
}

// wrapZerolog wraps the zerolog logger to be used within drone packages.
type wrapZerolog struct {
	inner zerolog.Logger
	err   error
}

func (w *wrapZerolog) WithError(err error) logger.Logger {
	return &wrapZerolog{inner: w.inner, err: err}
}

func (w *wrapZerolog) WithField(key string, value interface{}) logger.Logger {
	return &wrapZerolog{inner: w.inner.With().Str(key, fmt.Sprint(value)).Logger(), err: w.err}
}

func (w *wrapZerolog) Debug(args ...interface{}) {
	w.inner.Debug().Err(w.err).Msg(fmt.Sprint(args...))
}

func (w *wrapZerolog) Debugf(format string, args ...interface{}) {
	w.inner.Debug().Err(w.err).Msgf(format, args...)
}

func (w *wrapZerolog) Debugln(args ...interface{}) {
	w.inner.Debug().Err(w.err).Msg(fmt.Sprintln(args...))
}

func (w *wrapZerolog) Error(args ...interface{}) {
	w.inner.Error().Err(w.err).Msg(fmt.Sprint(args...))
}

func (w *wrapZerolog) Errorf(format string, args ...interface{}) {
	w.inner.Error().Err(w.err).Msgf(format, args...)
}

func (w *wrapZerolog) Errorln(args ...interface{}) {
	w.inner.Error().Err(w.err).Msg(fmt.Sprintln(args...))
}

func (w *wrapZerolog) Info(args ...interface{}) {
	w.inner.Info().Err(w.err).Msg(fmt.Sprint(args...))
}

func (w *wrapZerolog) Infof(format string, args ...interface{}) {
	w.inner.Info().Err(w.err).Msgf(format, args...)
}

func (w *wrapZerolog) Infoln(args ...interface{}) {
	w.inner.Info().Err(w.err).Msg(fmt.Sprintln(args...))
}

func (w *wrapZerolog) Trace(args ...interface{}) {
	w.inner.Trace().Err(w.err).Msg(fmt.Sprint(args...))
}

func (w *wrapZerolog) Tracef(format string, args ...interface{}) {
	w.inner.Trace().Err(w.err).Msgf(format, args...)
}

func (w *wrapZerolog) Traceln(args ...interface{}) {
	w.inner.Trace().Err(w.err).Msg(fmt.Sprintln(args...))
}

func (w *wrapZerolog) Warn(args ...interface{}) {
	w.inner.Warn().Err(w.err).Msg(fmt.Sprint(args...))
}

func (w *wrapZerolog) Warnf(format string, args ...interface{}) {
	w.inner.Warn().Err(w.err).Msgf(format, args...)
}

func (w *wrapZerolog) Warnln(args ...interface{}) {
	w.inner.Warn().Err(w.err).Msg(fmt.Sprintln(args...))
}
// Copyright 2023 Harness, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package starlark

import (
	"strings"

	"github.com/harness/gitness


u_si256(CONST_M256_CAST(cv_l+4)));
	_mm256_storeu_si256(M256_CAST(cv_l+4),
		_mm256_loadu_si256(CONST_M256_CAST(cv_r+4)));

	_mm256_storeu_si256(M256_CAST(cv_r+0), temp[0]);
	_mm256_storeu_si256(M256_CAST(cv_r+4), temp[1]);
};

/* -------------------------------------------------------- *
* step function
* -------------------------------------------------------- */

template <unsigned int Alpha, unsigned int Beta>
inline void mix(lsh_u64 cv_l[8], lsh_u64 cv_r[8], const lsh_u64 const_v[8])
{
	add_blk(cv_l, cv_r);
	rotate_blk<Alpha>(cv_l);
	xor_with_const(cv_l, const_v);
	add_blk(cv_r, cv_l);
	rotate_blk<Beta>(cv_r);
	add_blk(cv_l, cv_r);
	rotate_msg_gamma(cv_r);
}

/* -------------------------------------------------------- *
* compression function
* -------------------------------------------------------- */

inline void compress(LSH512_AVX2_Context* ctx, const lsh_u8 pdMsgBlk[LSH512_MSG_BLK_BYTE_LEN])
{
	CRYPTOPP_ASSERT(ctx != NULLPTR);

	LSH512_AVX2_Internal  s_state(ctx->cv_l);
	LSH512_AVX2_Internal* i_state = &s_state;

	const lsh_u64* const_v = NULL;
	lsh_u64 *cv_l = ctx->cv_l;
	lsh_u64 *cv_r = ctx->cv_r;

	load_msg_blk(i_state, pdMsgBlk);

	msg_add_even(cv_l, cv_r, i_state);
	load_sc(&const_v, 0);
	mix<ROT_EVEN_ALPHA, ROT_EVEN_BETA>(cv_l, cv_r, const_v);
	word_perm(cv_l, cv_r);

	msg_add_odd(cv_l, cv_r, i_state);
	load_sc(&const_v, 8);
	mix<ROT_ODD_ALPHA, ROT_ODD_BETA>(cv_l, cv_r, const_v);
	word_perm(cv_l, cv_r);

	for (size_t i = 1; i < NUM_STEPS / 2; i++)
	{
		msg_exp_even(i_state);
		msg_add_even(cv_l, cv_r, i_state);
		load_sc(&const_v, 16 * i);
		mix<ROT_EVEN_ALPHA, ROT_EVEN_BETA>(cv_l, cv_r, const_v);
		word_perm(cv_l, cv_r);

		msg_exp_odd(i_state);
		msg_add_odd(cv_l, cv_r, i_state);
		load_sc(&const_v, 16 * i + 8);
		mix<ROT_ODD_ALPHA, ROT_ODD_BETA>(cv_l, cv_r, const_v);
		word_perm(cv_l, cv_r);
	}

	msg_exp_even(i_state);
	msg_add_even(cv_l, cv_r, i_state);
}

/* -------------------------------------------------------- */

inline void load_iv(word64 cv_l


requires_sorted_storage);
    EXPECT_ROCSPARSE_STATUS(rocsparse_prune_csr2csr<T>(PARAMS),
                            rocsparse_status_requires_sorted_storage);
#undef PARAMS
#undef PARAMS_NNZ
#undef PARAMS_BUFFER_SIZE
}

template <typename T>
void testing_prune_csr2csr(const Arguments& arg)
{
    rocsparse_matrix_factory<T> matrix_factory(arg);
    rocsparse_int               M          = arg.M;
    rocsparse_int               N          = arg.N;
    rocsparse_index_base        csr_base_A = arg.baseA;
    rocsparse_index_base        csr_base_C = arg.baseB;

    host_scalar<T> h_threshold(arg.threshold);

    // Create rocsparse handle
    rocsparse_local_handle handle(arg);

    rocsparse_local_mat_descr csr_descr_A;
    rocsparse_local_mat_descr csr_descr_C;

    CHECK_ROCSPARSE_ERROR(rocsparse_set_mat_index_base(csr_descr_A, csr_base_A));
    CHECK_ROCSPARSE_ERROR(rocsparse_set_mat_index_base(csr_descr_C, csr_base_C));

    // Allocate host memory for output CSR matrix
    host_vector<rocsparse_int> h_csr_row_ptr_A;
    host_vector<rocsparse_int> h_csr_col_ind_A;
    host_vector<T>             h_csr_val_A;

    host_vector<rocsparse_int> h_nnz_total_dev_host_ptr(1);

    // Generate uncompressed CSR matrix on host (or read from file)
    rocsparse_int nnz_A = 0;
    matrix_factory.init_csr(h_csr_row_ptr_A, h_csr_col_ind_A, h_csr_val_A, M, N, nnz_A, csr_base_A);

    // Allocate device memory for input CSR matrix
    device_vector<rocsparse_int> d_nnz_total_dev_host_ptr(1);
    device_vector<rocsparse_int> d_csr_row_ptr_C(M + 1);
    device_vector<rocsparse_int> d_csr_row_ptr_A(M + 1);
    device_vector<rocsparse_int> d_csr_col_ind_A(nnz_A);
    device_vector<T>             d_csr_val_A(nnz_A);
    device_scalar<T>             d_threshold(h_threshold);

    // Copy data from CPU to device
    CHECK_HIP_ERROR(hipMemcpy(
        d_csr_row_ptr_A, h_csr_row_ptr_A, sizeof(rocsparse_int) * (M + 1), hipMemcpyHostToDevice));
    CHECK_HIP_ERROR(hipMemcpy(
        d_csr_col_ind_A, h_csr_col_ind_A, sizeof(rocsparse_int) * nnz_A, hipMemcpyHostToDevice));
    CHECK_HIP_ERROR(hipMemcpy(d_csr_val_A, h_csr_val_A, sizeof(T) * nnz_A, hipMemcpyHostToDevice));

    size_t buffer_size = 0;
    CHECK_ROCSPARSE_ERROR(rocsparse_prune_csr2csr_buffer_size<T>(handle,
                                                                 M,
                                                                 N,
                                                                 nnz_A,
                                                                 csr_descr_A,
                                                                 d_csr_val_A,
                                                                 d_csr_row_ptr_A,
                                                                 d_csr_col_ind_