AndSettle();
      await tester.tap(find.byKey(ArchSampleKeys.statsTab));
      await tester.pump();

      expect(find.byKey(ArchSampleKeys.statsNumActive), findsOneWidget);
      expect(find.byKey(ArchSampleKeys.statsNumActive), findsOneWidget);
    });
  });
}

class _TestWidget extends StatelessWidget {
  const _TestWidget({
    required this.todosInteractor,
    required this.userRepository,
  });

  final TodosInteractor todosInteractor;
  final UserRepository userRepository;

  @override
  Widget build(BuildContext context) {
    return Injector(
      todosInteractor: todosInteractor,
      userRepository: userRepository,
      child: TodosBlocProvider(
        bloc: TodosListBloc(todosInteractor),
        child: MaterialApp(
          localizationsDelegates: [
            SimpleBlocLocalizationsDelegate(),
            ArchSampleLocalizationsDelegate(),
          ],
          home: const HomeScreen(),
        ),
      ),
    );
  }

  static List<Todo> get _defaultTodos {
    return [
      Todo('T1', id: '1', note: 'N1'),
      Todo('T2', id: '2'),
      Todo('T3', id: '3', complete: true),
    ];
  }
}

Matcher isChecked(bool isChecked) {
  return matchesSemantics(
    isChecked: isChecked,
    hasTapAction: true,
    hasFocusAction: true,
    hasCheckedState: true,
    isFocusable: true,
    hasEnabledState: true,
    isEnabled: true,
  );
}
import 'package:flutter/material.dart';
import 'package:freezed_provider_value_notifier/todo_list_model.dart';
import 'package:provider/provider.dart';
import 'package:todos_app_core/todos_app_core.dart';

class FilterButton extends StatelessWidget {
  final bool isActive;

  const FilterButton({super.key, required this.isActive});

  @override
  Widget build(BuildContext context) {
    return IgnorePointer(
      ignoring: !isActive,
      child: AnimatedOpacity(
        opacity: isActive ? 1.0 : 0.0,
        duration: const Duration(milliseconds: 150),
        child: Consumer<TodoList>(
          builder: (context, model, _) {
            return PopupMenuButton<VisibilityFilter>(
              key: ArchSampleKeys.filterButton,
              tooltip: ArchSampleLocalizations.of(context).filterTodos,
              initialValue: model.filter,
              onSelected: (filter) =>
                  context.read<TodoListController>().filter = filter,
              itemBuilder: (BuildContext context) => _items(context, model),
              icon: const Icon(Icons.filter_list),
            );
          },
        ),
      ),
    );
  }

  List<PopupMenuItem<VisibilityFilter>> _items(
    BuildContext context,
    TodoList store,
  ) {
    final defaultStyle = Theme.of(context).textTheme.bodyMedium!;
    final activeStyle = defaultStyle.copyWith(
      color: Theme.of(context).colorScheme.secondary,
    );

    return [
      PopupMenuItem<VisibilityFilter>(
        key: ArchSampleKeys.allFilter,
        value: VisibilityFilter.all,
        child: Text(
          ArchSampleLocalizations.of(context).showAll,
          style: store.filter == VisibilityFilter.all
              ? activeStyle
              : defaultStyle,
        ),
      ),
      PopupMenuItem<VisibilityFilter>(
        key: ArchSampleKeys.activeFilter,
        value: VisibilityFilter.active,
        child: Text(
          ArchSampleLocalizations.of(context).showActive,
          style: store.filter == V


# flake8: noqa
# There's no way to ignore "F401 '...' imported but unused" warnings in this
# module, but to preserve other warnings. So, don't check this module at all

# coding=utf-8
# Copyright 2023-present the HuggingFace Inc. team.
#
# 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.

# from .config import PeftConfig, PeftType, PromptLearningConfig, TaskType
from .loftq_utils import replace_lora_weights_loftq
from .peft_types import PeftType, TaskType
from .other import (
    TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
    TRANSFORMERS_MODELS_TO_LORA_TARGET_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_ADALORA_TARGET_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_IA3_TARGET_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_IA3_FEEDFORWARD_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_LNTUNING_TARGET_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_VERA_TARGET_MODULES_MAPPING,
    TRANSFORMERS_MODELS_TO_PACA_TARGET_MODULES_MAPPING,
    CONFIG_NAME,
    WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    INCLUDE_LINEAR_LAYERS_SHORTHAND,
    _set_trainable,
    bloom_model_postprocess_past_key_value,
    prepare_model_for_kbit_training,
    shift_tokens_right,
    transpose,
    _get_batch_size,
    _get_submodules,
    _set_adapter,
    _freeze_adapter,
    ModulesToSaveWrapper,
    _prepare_prompt_learning_config,
    _is_valid_match,
    infer_device,
    get_auto_gptq_quant_linear,
    get_quantization_config,
    id_tensor_storage,
    cast_mixed_precision_params,
)
from .save_and_load import get_peft_model_state_dict, set_peft_model_state_dict, load_peft_weights


76] = "惊怖精华",
[98079] = "吹笛人的外套",
[98080] = "华贵上衣",
[98081] = "爆炸衫",
[98082] = "终极勇士的衬衣",
[98083] = "鲨鱼皮外套",
[98084] = "沾泥的衬衣",
[98085] = "鳄皮卫衣",
[98086] = "燕尾服式的衬衣",
[98087] = "纸衬衣",
[98088] = "断裂日曜石",
[98089] = "狂热朱砂玛瑙",
[98090] = "刚硬河心石",
[98091] = "末季衬衣",
[98092] = "挖掘专家的外套",
[98093] = "炫目衬衣",
[98094] = "闪耀源红石",
[98095] = "格斗家的宠物补给品",
[98096] = "一小包钱币",
[98097] = "一大包钱币",
[98098] = "满满一包钱币",
[98099] = "超大包钱币",
[98100] = "一小袋钱币",
[98101] = "一大袋钱币",
[98102] = "满满一袋钱币",
[98103] = "超大袋钱币",
[98104] = "红色装甲龙鹰",
[98105] = "Art Template Cloth Cloak - Cape_Pandaria_DragonCaster_D_01",
[98106] = "Art Template Cloth Cloak - Cape_Pandaria_DragonCaster_D_02",
[98107] = "Art Template Cloth Cloak - Cape_Pandaria_OxTank_D_01",
[98108] = "Art Template Cloth Cloak - Cape_Pandaria_OxTank_D_02",
[98109] = "Art Template Cloth Cloak - Cape_Pandaria_TigerMelee_D_01",
[98110] = "Art Template Cloth Cloak - Cape_Pandaria_TigerMelee_D_02",
[98111] = "科罐乐",
[98112] = "次级宠物糕点",
[98113] = "一叠信件",
[98114] = "宠物糕点",
[98115] = "纪念项链",
[98116] = "速冻土狼肉干",
[98117] = "金钱蜜酒",
[98118] = "松脆蝎子",
[98119] = "难以辨认的图纸",
[98120] = "发货单",
[98121] = "琥珀种子包",
[98122] = "裂蹄牛奶酪",
[98123] = "鲸鲨鱼子酱",
[98124] = "血莓挞",
[98125] = "刀削赞加松露",
[98126] = "机械鸟鹅肝酱",
[98127] = "有凹陷的卡亚可乐罐",
[98129] = "Monster - Gun - Outland Raid D04 (Blue)",
[98130] = "Monster - Gun - Outland Raid D04 (Red)",
[98132] = "影踪喷枪",
[98133] = "大宝箱",
[98134]


",
       "ML",
       "MT",
       "MH",
       "MQ",
       "MR",
       "MU",
       "YT",
       "MX",
       "FM",
       "MD",
       "MC",
       "MN",
       "ME",
       "MS",
       "MA",
       "MZ",
       "MM",
       "NA",
       "NR",
       "NP",
       "NL",
       "AN",
       "NC",
       "NZ",
       "NI",
       "NE",
       "NG",
       "NU",
       "NF",
       "MP",
       "NO",
       "OM",
       "PK",
       "PW",
       "PS",
       "PA",
       "PG",
       "PY",
       "PE",
       "PH",
       "PN",
       "PL",
       "PT",
       "PR",
       "QA",
       "RS",
       "RE",
       "RO",
       "RU",
       "RW",
       "BL",
       "SH",
       "KN",
       "LC",
       "MF",
       "PM",
       "VC",
       "WS",
       "SM",
       "ST",
       "SA",
       "SN",
       "CS",
       "SC",
       "SL",
       "SG",
       "SX",
       "SK",
       "SI",
       "SB",
       "SO",
       "ZA",
       "GS",
       "SS",
       "ES",
       "LK",
       "SD",
       "SR",
       "SJ",
       "SZ",
       "SE",
       "CH",
       "SY",
       "TW",
       "TJ",


家”、“不理他”！

   各系均先后选了代表，于晚上召开【清华第一次代表大会】，要求尽快成立主席团。会上贺鹏飞作了长篇讲话。

   晚，《毛泽东主义红卫兵》在中央主楼后厅，请北京军区学习毛主席著作积极分子介绍经验会，与【第一次代表大会】时间发生冲突。会前贺鹏飞曾同意开此会，但至晚7时，广播台却突然广播说：《临筹》没有同意开此会。

    9月10日

   许多串联会斗本系黑帮。

   《毛泽东主义红卫兵》改名为《毛泽东思想红卫兵》。晚，《毛泽东思想红卫兵》总部开会，讨论选举问题。毛泽东思想《临时总部》的主要负责人是吴栋。

    9月11日

   《人民日报》社论：【工农群众和革命学生在毛泽东思想旗帜下团结起来】。

   《毛泽东思想红卫兵》发表决议和命令，认为当前的中心任务是选举，同时进行斗黑帮的准备工作。认为因外出人员太多，选举的应是临时主席团。以不合法行径选举出的代表，应取消代表资格。并命令《毛泽东思想红卫兵》、《东方红公社》社员，每天坚持两小时毛选学习，要和工农相结合。

    9月12日

   《东方红南下革命串联队先锋队》于昆明云南大学写出：【再论革命的怀疑一切──砸碎形而上学的谬论】。

   土建系召开控诉大会（斗争黑帮誓师大会），会前演雕塑剧【收租院】。土建系主持的【革命造反展览会】正式开放。

   《临筹》曾发布决议，允许按观点串联，


override void OnObjectDropped( UnityEngine.Object obj )
		{
			ConfigFromObject( obj );
		}

		public override void SetupFromCastObject( UnityEngine.Object obj )
		{
			ConfigFromObject( obj );
		}

		public override string GenerateShaderForOutput( int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar )
		{
			if( m_substanceGraph == null )
			{
				return "(0).xxxx";
			}

			if( m_outputPorts[ outputId ].IsLocalValue( dataCollector.PortCategory ) )
			{
				return m_outputPorts[ outputId ].LocalValue( dataCollector.PortCategory );
			}

			List<Texture2D> textures = m_substanceGraph.generatedTextures;

			string uvPropertyName = string.Empty;
			for( int i = 0; i < m_outputPorts.Count; i++ )
			{
				if( m_outputPorts[ i ].HasConnectedNode  )
				{
					uvPropertyName = UIUtils.GeneratePropertyName( textures[ i ].name , PropertyType.Property );
					break;
				}
			}

			string propertyName = UIUtils.GeneratePropertyName( textures[ outputId ].name, PropertyType.Property );
			string name = propertyName + OutputId;
			dataCollector.AddToUniforms( UniqueId, string.Format( GlobalVarDecStr, propertyName ) );
			dataCollector.AddToProperties( UniqueId, string.Format( PropertyDecStr, propertyName, textures[ outputId ].name ) + "{}", -1 );
			bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation );
			string value = string.Format( "tex2D{0}({1}, {2})", ( isVertex ? "lod" : string.Empty ), propertyName, GetUVCoords( ref dataCollector, ignoreLocalvar, uvPropertyName ) );
			if( m_autoNormal && m_textureTypes[ outputId ] == ASEProceduralOutputType.Normal )
			{
				value = GeneratorUtils.GenerateUnpackNormalStr( ref dataCollector, CurrentPrecisionType, UniqueId, OutputId, value, false, "1.0" );
			}

			dataCollector.AddPropertyNode( this );
			RegisterLocalVariable( outputId, value, ref dataCollector, name );

			return m_outputPorts[ outputId ].LocalValue( dataCollector.PortCategory );
		}

		public string GetUVCoords( ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar, string propertyName )
		{
			bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation );
			if( m_inputPorts[ 0 ].IsConnected )
			{
				return m_inputPorts[ 0 ].GenerateShaderForOutput( ref dataCollector, isVertex ? WirePortDataType.FLOAT4 : WirePortDataType.FLOAT2, ignoreLocalVar, true );
			}
			else
			{
				string uvChannelName = IOUtils.GetUVChannelName( propertyName, m_textureCoordSet );

				if( dataCollector.IsTemplate )
				{
					string propertyHelperVar = propertyName + "_ST";
					dataCollector.AddToUniforms( UniqueId, "float4", propertyHelperVar, dataCollector.IsSRP );
					string uvName = string.Empty;
					string result = string.Empty;
					if( dataCollector.TemplateDataCollectorInstance.GetCustomInterpolatedData( TemplateHelperFunctions.IntToUVChannelInfo[ m_textureCoordSet ], WirePortDataType.FLOAT4, PrecisionType.Float, ref result, false, dataCollector.PortCategory ) )
					{
						if( m_inputPorts[ 0 ].DataType != WirePortDataType.FLOAT4 )
							result += UIUtils.GetAutoSwizzle( m_inputPorts[ 0 ].DataType );
						uvName = result;
					}


 the active goroutine stack profile.
// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
// If len(p) < n, GoroutineProfile does not change p and returns n, false.
//
// Most clients should use the runtime/pprof package instead
// of calling GoroutineProfile directly.
func GoroutineProfile(p []StackRecord) (n int, ok bool) {
	gp := getg()

	isOK := func(gp1 *g) bool {
		// Checking isSystemGoroutine here makes GoroutineProfile
		// consistent with both NumGoroutine and Stack.
		return gp1 != gp && readgstatus(gp1) != _Gdead && !isSystemGoroutine(gp1)
	}

	stopTheWorld("profile")

	n = 1
	for _, gp1 := range allgs {
		if isOK(gp1) {
			n++
		}
	}

	if n <= len(p) {
		ok = true
		r := p

		// Save current goroutine.
		sp := getcallersp(unsafe.Pointer(&p))
		pc := getcallerpc(unsafe.Pointer(&p))
		systemstack(func() {
			saveg(pc, sp, gp, &r[0])
		})
		r = r[1:]

		// Save other goroutines.
		for _, gp1 := range allgs {
			if isOK(gp1) {
				if len(r) == 0 {
					// Should be impossible, but better to return a
					// truncated profile than to crash the entire process.
					break
				}
				saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
				r = r[1:]
			}
		}
	}

	startTheWorld()

	return n, ok
}

func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
	n := gentraceback(pc, sp, 0, gp, 0, &r.Stack0[0], len(r.Stack0), nil, nil, 0)
	if n < len(r.Stack0) {
		r.Stack0[n] = 0
	}
}

// Stack formats a stack trace of the calling goroutine into buf
// and returns the number of bytes written to buf.
// If all is true, Stack formats stack traces of all other goroutines
// into buf after the trace for the current goroutine.
func Stack(buf []byte, all bool) int {
	if all {
		stopTheWorld("stack trace")
	}

	n := 0
	if len(buf) > 0 {
		gp := getg()
		sp := getcallersp(unsafe.Pointer(&buf))
		pc := getcallerpc(unsafe.Pointer(&buf))
		systemstack(func() {
			g0 := getg()
			// Force traceback=1 to override GOTRACEBACK setting,
			// so that Stack's results are consistent.
			// GOTRACEBACK is only about crash dumps.
			g0.m.traceback = 1
			g0.writebuf = buf[0:0:len(buf)]
			goroutineheader(gp)
			traceback(pc, sp, 0, gp)
			if all {
				tracebackothers(gp)
			}
			g0.m.traceback = 0
			n = len(g0.writebuf)
			g0.writebuf = nil
		})
	}

	if all {
		startTheWorld()
	}
	return n
}

// Tracing of alloc/free/gc.

var tracelock mutex

func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
	lock(&tracelock)
	gp := getg()
	gp.m.traceback = 2
	if typ == nil {
		print("tracealloc(", p, ", ", hex(size), ")\n")
	} else {
		print("tracealloc(", p, ", ", hex(size), ", ", typ.string(), ")\n")
	}


batisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;

import com.dao.JiaxuefenjiangliDao;
import com.entity.JiaxuefenjiangliEntity;
import com.service.JiaxuefenjiangliService;
import com.entity.vo.JiaxuefenjiangliVO;
import com.entity.view.JiaxuefenjiangliView;

@Service("jiaxuefenjiangliService")
public class JiaxuefenjiangliServiceImpl extends ServiceImpl<JiaxuefenjiangliDao, JiaxuefenjiangliEntity> implements JiaxuefenjiangliService {

    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        Page<JiaxuefenjiangliEntity> page = this.selectPage(
                new Query<JiaxuefenjiangliEntity>(params).getPage(),
                new EntityWrapper<JiaxuefenjiangliEntity>()
        );
        return new PageUtils(page);
    }

    @Override
	public PageUtils queryPage(Map<String, Object> params, Wrapper<JiaxuefenjiangliEntity> wrapper) {
		  Page<JiaxuefenjiangliView> page =new Query<JiaxuefenjiangliView>(params).getPage();
	        page.setRecords(baseMapper.selectListView(page,wrapper));
	    	PageUtils pageUtil = new PageUtils(page);
	    	return pageUtil;
 	}

    @Override
	public List<JiaxuefenjiangliVO> selectListVO(Wrapper<JiaxuefenjiangliEntity> wrapper) {
 		return baseMapper.selectListVO(wrapper);
	}

	@Override
	public JiaxuefenjiangliVO selectVO(Wrapper<JiaxuefenjiangliEntity> wrapper) {
 		return baseMapper.selectVO(wrapper);
	}

	@Override
	public List<JiaxuefenjiangliView> selectListView(Wrapper<JiaxuefenjiangliEntity> wrapper) {
		return baseMapper.selectListView(wrapper);
	}

	@Override
	public JiaxuefenjiangliView selectView(Wrapper<JiaxuefenjiangliEntity> wrapper) {
		return baseMapper.selectView(wrapper);
	}

    @Override
    public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<JiaxuefenjiangliEntity> wrapper) {
        return baseMapper.selectValue(params, wrapper);
    }

    @Override
    public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<JiaxuefenjiangliEntity> wrapper) {
        return baseMapper.selectTimeStatValue(params, wrapper);
    }

    @Override
    public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<JiaxuefenjiangliEntity> wrapper) {
        return baseMapper.selectGroup(params, wrapper);
    }

}
package com.entity;

import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.


mask.classList.remove('dplayer-mask-show');
        this.player.template.menu.classList.remove('dplayer-menu-show');

        this.shown = false;
        this.player.events.trigger('contextmenu_hide');
    }
}

export default ContextMenu;
const isMobile = /mobile/i.test(window.navigator.userAgent);

const utils = {

    /**
    * Parse second to time string
    *
    * @param {Number} second
    * @return {String} 00:00 or 00:00:00
    */
    secondToTime: (second) => {
        const add0 = (num) => num < 10 ? '0' + num : '' + num;
        const hour = Math.floor(second / 3600);
        const min = Math.floor((second - hour * 3600) / 60);
        const sec = Math.floor(second - hour * 3600 - min * 60);
        return (hour > 0 ? [hour, min, sec] : [min, sec]).map(add0).join(':');
    },

    /**
     * control play progress
     */
    // get element's view position
    getElementViewLeft: (element) => {
        let actualLeft = element.offsetLeft;
        let current = element.offsetParent;
        const elementScrollLeft = document.body.scrollLeft + document.documentElement.scrollLeft;
        if (!document.fullscreenElement && !document.mozFullScreenElement && !document.webkitFullscreenElement) {
            while (current !== null) {
                actualLeft += current.offsetLeft;
                current = current.offsetParent;
            }
        }
        else {
            while (current !== null && current !== element) {
                actualLeft += current.offsetLeft;
                current = current.offsetParent;
            }
        }
        return actualLeft - elementScrollLeft;
    },

    /**
    * optimize control play progress

    * optimize get element's view position,for float dialog video player
    * getBoundingClientRect 在 IE8 及以下返回的值缺失 width、height 值
    * getBoundingClientRect 在 Firefox 11 及以下返回的值会把 transform 的值也包含进去
    * getBoundingClientRect 在 Opera 10.5 及以下返回的值缺失 width、height 值
    */
    getBoundingClientRectViewLeft (element) {
        const scrollTop = document.documentElement.scrollTop;

        if (element.getBoundingClientRect) {
            if (typeof this.getBoundingClientRectViewLeft.offset !== 'number') {
                let temp = document.createElement('div');
                temp.style.cssText = 'position:absolute;top:0;left:0;';
                document.body.appendChild(temp);
                this.getBoundingClientRectViewLeft.offset = -temp.getBoundingClientRect().top - scrollTop;
                document.body.removeChild(temp);
                temp = null;
            }
            const rect = element.getBoundingClientRect();
            const offset = this.getBoundingClientRectViewLeft.offset;

            return rect.left + offset;
        } else {
            // not support getBoundingClientRect
            return this.getElementViewLeft(element);
        }
    },

    getScrollPosition () {
        return {
            left: window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0,
            top: window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0
        };
    },

    setScrollPosition ({left = 0, top = 0}) {
        if (this.isFirefox) {
            document.documentElement.scrollLeft = left;
            document.documentElement.scrollTop = top;
        }
        else {
            window.scrollTo(left, top);
        }
    },

    isMobile: isMobile,

    isFirefox: /firefox/i.test(window.navigator.userAgent),

    isChrome: /chrome/i.tes


_)." % (bucket, invalid.groups()[0]))

	if len(bucket) < 3:
		raise Exceptions.ParameterError("Bucket name '%s' is too short (min 3 characters)" % bucket)
	if len(bucket) > 255:
		raise Exceptions.ParameterError("Bucket name '%s' is too long (max 255 characters)" % bucket)
	if dns_strict:
		if len(bucket) > 63:
			raise Exceptions.ParameterError("Bucket name '%s' is too long (max 63 characters)" % bucket)
		if re.search("-\.", bucket):
			raise Exceptions.ParameterError("Bucket name '%s' must not contain sequence '-.' for DNS compatibility" % bucket)
		if re.search("\.\.", bucket):
			raise Exceptions.ParameterError("Bucket name '%s' must not contain sequence '..' for DNS compatibility" % bucket)
		if not re.search("^[0-9a-z]", bucket):
			raise Exceptions.ParameterError("Bucket name '%s' must start with a letter or a digit" % bucket)
		if not re.search("[0-9a-z]$", bucket):
			raise Exceptions.ParameterError("Bucket name '%s' must end with a letter or a digit" % bucket)
	return True
__all__.append("check_bucket_name")

def check_bucket_name_dns_conformity(bucket):
	try:
		return check_bucket_name(bucket, dns_strict = True)
	except Exceptions.ParameterError:
		return False
__all__.append("check_bucket_name_dns_conformity")

def getBucketFromHostname(hostname):
	"""
	bucket, success = getBucketFromHostname(hostname)

	Only works for hostnames derived from bucket names
	using Config.host_bucket pattern.

	Returns bucket name and a boolean success flag.
	"""

	# Create RE pattern from Config.host_bucket
	pattern = Config.Config().host_bucket % { 'bucket' : '(?P<bucket>.*)' }
	m = re.match(pattern, hostname)
	if not m:
		return (hostname, False)
	return m.groups()[0], True
__all__.append("getBucketFromHostname")

def getHostnameFromBucket(bucket):
	return Config.Config().host_bucket % { 'bucket' : bucket }
__all__.append("getHostnameFromBucket")


NameTest, Equality) {
  // test equality api
  auto foo1 = QualifiedName("foo.bar.baz");
  auto foo2 = QualifiedName("foo.bar.baz");
  auto foo3 = QualifiedName("bar.bar.baz");
  ASSERT_EQ(foo1, foo2);
  ASSERT_NE(foo1, foo3);
  auto bar1 = QualifiedName("sup");
  auto bar2 = QualifiedName("sup");
  ASSERT_EQ(foo1, foo2);
}

TEST(QualifiedNameTest, IsPrefixOf) {
  // test prefix api
  auto foo1 = QualifiedName("foo.bar.baz");
  auto foo2 = QualifiedName("foo.bar");
  auto foo3 = QualifiedName("bar.bar.baz");
  auto foo4 = QualifiedName("foo.bar");
  ASSERT_TRUE(foo2.isPrefixOf(foo1));
  ASSERT_TRUE(foo2.isPrefixOf(foo4));
  ASSERT_TRUE(foo4.isPrefixOf(foo2));
  ASSERT_FALSE(foo1.isPrefixOf(foo2));
  ASSERT_FALSE(foo2.isPrefixOf(foo3));
}
} // namespace jit
} // namespace torch
#include <memory>

#include <gtest/gtest.h>

#include <ATen/ATen.h>
#include <torch/csrc/distributed/autograd/context/container.h>
#include <torch/csrc/distributed/autograd/context/context.h>
#include <torch/csrc/distributed/autograd/engine/dist_engine.h>
#include <torch/csrc/distributed/autograd/rpc_messages/rpc_with_autograd.h>
#include <torch/csrc/distributed/autograd/utils.h>
#include <torch/torch.h>

namespace torch {
namespace distributed {
namespace autograd {

class DistAutogradTest : public ::testing::Test {
 protected:
  static void SetUpTestCase() {
    autogradContainer_ = &DistAutogradContainer::init(0);
  }

  virtual void TearDown() {
    autogradContainer_->releaseContext(autogradContainer_->currentContext()->contextId());
  }

  static DistAutogradContainer* autogradContainer_;
};

DistAutogradContainer* DistAutogradTest::autogradContainer_ = nullptr;

TEST_F(DistAutogradTest, TestSendFunctionInvalidInputs) {
  auto options = at::TensorOptions().requires_grad(true);
  auto in1 = torch::ones({3, 3}, options);
  auto in2 = torch::ones({3, 3}, options);

  autogradContainer_->newContext();
  auto autogradContext = autogradContainer_->currentContext();
  // Attach the send autograd function to tensors.
  std::vector<torch::Tensor> tensors = {in1, in2};
  rpc::worker_id_t worker_id = 1;
  addSendRpcBackward(
      autogradContext, AutogradMetadata(1, 1), tensors);
  autogradContext->addKnownWorkerId(worker_id);
  auto send_function = autogradContext->sendFunctions()[1];

  // ensure that the worker_ids are recorded
  auto knownWorkerIds = autogradContext->getKnownWorkerIds();
  ASSERT_TRUE(knownWorkerIds.find(worker_id) != knownWorkerIds.end());
  ASSERT_EQ(knownWorkerIds.size(), 1);

  // This should fail since the SendRpcBackward function shouldn't receive any
  // inputs grad.
  EXPECT_THROW(send_function->apply({in1, in2}), c10::Error);

  // This should fail since the SendRpcBackward function encounters an undefined
  // grad.
  send_function->setGrads({in1, torch::autograd::Variable()});
  EXPECT_THROW(send_function


-- translation for Fire Package

return {
	["fire"] = "火包",

	["#xunyu"] = "王佐之才",
	["xunyu"] = "荀彧",
	["illustrator:xunyu"] = "LiuHeng",
	["quhu"] = "驱虎",
	[":quhu"] = "阶段技。你可以与一名体力值大于你的角色拼点：若你赢，该角色对其攻击范围内的一名由你选择的角色造成1点伤害；若你没赢，该角色对你造成1点伤害。",
	["@quhu-damage"] = "请选择 %src 攻击范围内的一名角色",
	["jieming"] = "节命",
	[":jieming"] = "每当你受到1点伤害后，你可以令一名角色将手牌补至X张。（X为该角色体力上限且至多为5）",
	["jieming-invoke"] = "你可以发动“节命”
 操作提示: 选择一名角色→点击确定
",
	["#QuhuNoWolf"] = "%from “驱虎”拼点赢，由于 %to 攻击范围内没有角色，结算中止",

	["#dianwei"] = "古之恶来",
	["dianwei"] = "典韦",
	["illustrator:dianwei"] = "小冷",
	["qiangxi"] = "强袭",
	[":qiangxi"] = "阶段技。你可以失去1点体力或弃置一张武器牌，并选择攻击范围内的一名角色：若如此做，你对该角色造成1点伤害。",

	["#wolong"] = "卧龙",
	["wolong"] = "卧龙诸葛亮",
	["&wolong"] = "诸葛亮",
	["illustrator:wolong"] = "北",
	["bazhen"] = "八阵",
	[":bazhen"] = "锁定技。若你的装备区没有防具牌，视为你装备【八卦阵】。",
	["huoji"] = "火计",
	[":huoji"] = "你可以将一张红色手牌当【火攻】使用。",
	["kanpo"] = "看破",
	[":kanpo"] = "你可以将一张黑色手牌当【无懈可击】使用。",

	["#pangtong"] = "凤雏",
	["pangto


[NodeJS]: https://nodejs.org/en
[eslint]: https://eslint.org/
[prettier]: https://prettier.io/
[MochaJS]: https://mochajs.org/
[ChaiJS]: https://www.chaijs.com/
[husky]: https://typicode.github.io/husky/
[VSCode dev containers]: https://code.visualstudio.com/docs/devcontainers/containers# A simple manual demo with Timelock

In this demo, we are using the [timelock][] contract as an example.  We do not
have an actual implementation of Solarkraft yet. Hence, we are manually
producing the verification steps that will be done by Solarkraft automatically
in the future.

We have written four monitors that capture various aspects of the smart contract:

 - [timelock_mon1.tla][] checks, whether the contract is initialized properly.
 - [timelock_mon2.tla][] checks, whether the contract balance is changing properly.
 - [timelock_mon3.tla][] checks, whether the `claimants` argument is respected.
 - [timelock_mon4.tla][] checks, whether the time bound is respected.

## 1. Setting up the dev environment

Follow the [setup][] guidelines from the Soroban tutorial.

After installing all the packages, we have generated one identity:

```sh
soroban config identity generate --global alice
```

## 2. Installing the timelock contract

Assuming that you have cloned [soroban-examples][] into `$EXAMPLES_HOME`,
do the following:

```sh
$ cd $EXAMPLES_HOME/timelock
$ soroban contract deploy \
  --wasm target/wasm32-unknown-unknown/release/soroban_timelock_contract.wasm \
  --source alice \
  --network testnet | tee .soroban/timelock-id
```

Make sure that the command output contains no errors but a contract id that
looks similar to the one below:

```
CC2SFVF5CWKUDLAQ2DT6OAYWA5DVEMLNWGPFCKIH6BK7GSVFSADX2TIX
```

## 3. Invoking an erroneous transaction

To illustrate the future workflow of Solakraft, we manually invoke the following
transaction, which fails in the simulation phase:

```sh
$ soroban contract invoke --id $(cat .soroban/timelock-id) \
  --source alice --network testnet --  claim --claimant alice
...
ERROR soroban_cli::log::diagnostic_event: 0: ...
error: transaction simulation failed: host invocation failed

Caused by:
    ...
    Event log (newest first):
       0: [Diagnostic Event] contract:b522d4bd159541ac10d0e7e70316074752316db19e512907f055f34aa590077d, topics:[error, Error(WasmVm, InvalidAction)], data:["VM call trapped: UnreachableCodeReached", claim]
```

## 4. Instrumenting the monitor

To check the above transaction, Solakraft will instrument the monitor
specification [timelock_mon1.tla][]:

```tla
---- MODULE timelock_mon1_instrumented ----
EXTENDS timelock_mon1

Init ==
    (* is_initialized is initialized from the current ledger state *)
    /\ is_initialized = FALSE
    /\ last_error = ""

Next ==
    (* the contract method being


experiments](https://arxiv.org/pdf/2408.13687) Figure S3. I think this is an OS issue and though I linked to [this post](https://shuhaowu.com/blog/2022/01-linux-rt-appdev-part1.html), I did not solve it myself.

Switching to GPU could be a solution. In my latency probing of the CUDA BP decoder, I did not observe such spikes, therefore I plan to implement a CUDA version of GDG. I should say beforehand that I don't expect the *theoretical* worst-case latency to improve much, since 200 iterations of CUDA BP takes 2ms on my RTX4090.

## 3. Heuristics

### 3.1 How do you tune BP+OSD parameters?

For the scaling factor, on code-capacity noise (data qubit noise), I try all four values from {0.5, 0.625, 0.8, 1.0} and pick the best one. For BB codes, see Fig. 4 from our paper for the best scaling factors. For circuit-level noise, from my experience $1.0$ is okay, probably because the Tanner graph is highly-irregular.

For BP iterations, I just set it to 100~200 for code-capcity noise without any tuning; I think a suitable scaling factor is more important there. However, for circuit-level noise, since I was doing the shortening trick to the wide circuit-level PCM (see `Sliding Window OSD.ipynb` for details) before running GDG, I found that running BP for too many iterations before shortening causes error floor.

### 3.2 What are the main features of GDG?

GDG is an ensembled BP-based decoder and there is no dependency within the ensemble. Moreover, it is iterative and each time it chooses the most-likely-to-flip VN to decimate. Each agent within the ensemble either decimates that VN according to the sign of the BP posterior LLR, or contrary to that, this is prefixed for each agent.

### 3.3 If I want to design other decoders, what heuristics can be transferred there?

- One could use LLR history to perform decisions, in our paper, we mostly only used the sum of the history, maybe better criterions can be devised.
- The shortening trick for circuit-level noise could be widely applicable.

---

*Still have questions? Feel free to contact me at gonga@student.ethz.ch.*
# EasyExcelPlus

  为简化开发工作、提高生产率而生

    <img alt="c


rrentArea() = 0;

  /**
   * Returns true if this scrollframe is being "actively scrolled".
   * This basically means that we should allocate resources in the
   * expectation that scrolling is going to happen.
   */
  virtual bool IsScrollingActive() = 0;
  /**
   * Call this when the layer(s) induced by active scrolling are being
   * completely redrawn.
   */
  virtual void ResetScrollPositionForLayerPixelAlignment() = 0;
  /**
   * Was the current presentation state for this frame restored from history?
   */
  virtual bool DidHistoryRestore() = 0;
  /**
   * Clear the flag so that DidHistoryRestore() returns false until the next
   * RestoreState call.
   * @see nsIStatefulFrame::RestoreState
   */
  virtual void ClearDidHistoryRestore() = 0;
};

#endif


: Node, type: string, listener: (event: EventListenerOrEventListenerObject) => void) {
    const fn = (ev: any) => {
      target.removeEventListener(type, fn);
      listener(ev);
    };
    target.addEventListener(type, fn);
  }
  export function onceOutside(target: Node, type: string, listener: (event: EventListenerOrEventListenerObject) => void) {
    const fn = (ev: any) => {
      const inside = target.contains(ev.target);
      if (!inside) {
        listener(ev);
        document.removeEventListener(type, fn);
      }
    };
    document.addEventListener(type, fn);
  }
  export function bindOutside(target: Node, type: string, listener: (event: EventListenerOrEventListenerObject) => void) {
    const fn = (ev: any) => {
      const inside = target.contains(ev.target);
      if (!inside) {
        listener(ev);
      }
    };
    document.addEventListener(type, fn);
  }
  export function bind(target: Node, type: string, listener: (event: EventListenerOrEventListenerObject) => void) {
    const fn = (ev: any) => {
      listener(ev);
    };
    target.addEventListener(type, fn);
  }
  // passive supported
  const passiveSupported = false;
  export function passive(): any {
    return (passiveSupported ? { passive: true } : false);
  }
  (function Initialize() {
    // detect if suport passive event
    try {
      const options = Object.defineProperty({}, "passive", {
        get: () => {
          this.passiveSupported = true;
        },
      });
      window.addEventListener("test", () => {
        return null;
      }, options);
    } catch (err) {
      //
    }
  })();
}
export default Event;
// ! QUERIES
// there are 151 pokemon
var allPokemonQuery: string = `
  query {
    pokemons(first: 151) {
      name
    }
  }
`

var pokemonInfoQuery: string = `
  query pokemon($name: String){
    pokemon(name: $name) {
      image
      number
      classification
    }
  }
`

// ! HTTP REQUESTS
async function fetchAllPokemon() {
  const res = await fetch("https://graphql-pokemon2.vercel.app", {
    method: 'POST',
    headers: {
      'content-type': 'application/json'
    },
    body: JSON.stringify({
      query: allPokemonQuery
    })
  })
  return res.json();
};

async function fetchPokemonInfo(name: string) {
  const res = await fetch("https://graphql-pokemon2.vercel.app", {
    method: "POST",
    headers: {
      "content-type": "application/json",
    },
    body: JSON.stringify({
      query: pokemonInfoQuery,
      variables: { name }
    }),
  });
  return res.json();
}

// ! Start app
fetchAllPokemon()
  .then(({ data: { pokemons }}) => {
    // attach a list of pokemons
    let ul: HTMLUListElement = document.createElement("ul");

    pokemons.forEach(( pokemon ) => {
      let li: HTMLLIElement = document.createElement("li");
      li.innerHTML = pokemon.name;

      // a flag to prevent appending pokemon info
      let clicked: Boolean = false;

      // add an event listener to the li so that the user may see more details on click
      li.addEventListener("click", () => {
        if (clicked) return;
        else clicked = true;

        fetchPokemonIn


mfhi	($12,$12,$7)
	addu	$2,$1
	sltu	$13,$2,$1
	 multu	($14,$7)
	sw	$2,0($4)
	addu	$2,$13,$12

	subu	$6,4
	addu $4,4*4
	addu $5,4*4
	mflo	($1,$14,$7)
	mfhi	($14,$14,$7)
	addu	$2,$1
	sltu	$15,$2,$1
	 multu	($8,$7)
	sw	$2,-3*4($4)
	addu	$2,$15,$14

	mflo	($1,$8,$7)
	mfhi	($8,$8,$7)
	addu	$2,$1
	sltu	$9,$2,$1
	 multu	($10,$7)
	sw	$2,-2*4($4)
	addu	$2,$9,$8

	and	$8,$6,$3
	mflo	($1,$10,$7)
	mfhi	($10,$10,$7)
	addu	$2,$1
	sltu	$11,$2,$1
	sw	$2,-4($4)
	.set	noreorder
	bgtz	$8,.L_bn_mul_words_loop
	addu	$2,$11,$10

	beqz	$6,.L_bn_mul_words_return
	nop

.L_bn_mul_words_tail:
	.set	reorder
	lw	$12,0($5)
	multu	($12,$7)
	subu	$6,1
	mflo	($1,$12,$7)
	mfhi	($12,$12,$7)
	addu	$2,$1
	sltu	$13,$2,$1
	sw	$2,0($4)
	addu	$2,$13,$12
	beqz	$6,.L_bn_mul_words_return

	lw	$12,4($5)
	multu	($12,$7)
	subu	$6,1
	mflo	($1,$12,$7)
	mfhi	($12,$12,$7)
	addu	$2,$1
	sltu	$13,$2,$1
	sw	$2,4($4)
	addu	$2,$13,$12
	beqz	$6,.L_bn_mul_words_return

	lw	$12,2*4($5)
	multu	($12,$7)
	mflo	($1,$12,$7)
	mfhi	($12,$12,$7)
	addu	$2,$1
	sltu	$13,$2,$1
	sw	$2,2*4($4)
	addu	$2,$13,$12

.L_bn_mul_words_return:
	.set	noreorder
	jr	$31
	move	$4,$2
.end	bn_mul_words_internal

.align	5
.globl	bn_sqr_words
.ent	bn_sqr_words
bn_sqr_words:
	.set	noreorder
	bgtz	$6,bn_sqr_words_internal
	move	$2,$0
	jr	$31
	move	$4,$2
.end	bn_sqr_words

.align	5
.ent	bn_sqr_words_internal
bn_sqr_words_internal:
	.set	reorder
	li	$3,-4
	and	$8,$6,$3
	beqz	$8,.L_bn_sqr_words_tail

.L_bn_sqr_words_loop:
	lw	$12,0($5)
	multu	($12,$12)
	lw	$14,4($5)
	lw	$8,2*4($5)
	lw	$10,3*4($5)


hall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "qtprotobufnamespace/tests/nested/neighbornested.h"
#include "qtprotobufnamespace/tests/nested/nestedfieldmessage.h"
#include "qtprotobufnamespace/tests/nested/nestedfieldmessage2.h"
#include "qtprotobufnamespace/tests/nested/nestedexternal.h"
#include "qtprotobufnamespace/tests/nested/nestednofields.h"
#include "qtprotobufnamespace/tests/nested/nestedcyclinga.h"
#include "qtprotobufnamespace/tests/nested/nestedcyclingaa.h"

#include "../test_protobuf/nestedtest.cpp.inc"
/*
 * MIT License
 *
 * Copyright (c) 2019 Alexey Edelev <semlanik@gmail.com>
 *
 * This file is part of QtProtobuf project https://git.semlanik.org/semlanik/qtprotobuf
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and
 * to permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
 * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "qtprotobufnamespace/tests/stepchildenummessage.h"
#include "qtprotobufnamespace/tests/simpleboolmessage.h"
#include "qtprotobufnamespace/tests/simpleintmessage.h"
#include "qtprotobufnamespace/tests/simplesintmessage.h"
#include "qtprotobufnamespace/tests/simpleuintmessage.h"
#include "qtprotobufnamespace/tests/simpleint64message.h"
#include "qtprotobufnamespace/tests/simplesint64message.h"
#include "qtprotobufnamespace/tests/simpleuint64message.h"
#include "qtprotobufnamespace/tests/simplefixedint32message.h"
#include "qtprotobufnamespace/tests/simplefixedint64message.h"
#include "qtprotobufnamespace/tests/simplesfixedint32message.h"
#include "qtprotobufnamespace/tests/simplesfixedint64message.h"
#include "qtprotobufnamespace/tests/simplestringmessage.h"
#include "qtprotobufnamespace/tests/simplefloatmessage.h"
#include "qtprotobufnamespace/tests/simpledoublemessage.h"
#include "qtprotobufnamespace/tests/simpleenummessage.h"
#include "qtprotobufnamespace/tests/simpleenumlistmessage.h"
#include "qtprotobufnamespace/tests/simplefileenummessage.h"
#include "qtprotobufnamespace/tests/simpleexternalenummessage.h"
#include "qt


list<int> intList;
			eastl::list<int>::iterator intListIterator = eastl::begin(intList);
			EATEST_VERIFY(intListIterator == eastl::end(intList));

			eastl::set<int> intSet;
			eastl::set<int>::iterator intSetIterator = eastl::begin(intSet);
			EATEST_VERIFY(intSetIterator == eastl::end(intSet));

			eastl::array<int, 0> intArray;
			eastl::array<int, 0>::iterator intArrayIterator = eastl::begin(intArray);
			EATEST_VERIFY(intArrayIterator == eastl::end(intArray));

			eastl::intrusive_list<IListNode> intIList;
			eastl::intrusive_list<IListNode>::iterator intIListIterator = eastl::begin(intIList);
			EATEST_VERIFY(intIListIterator == eastl::end(intIList));

			eastl::string8 str8;
			eastl::string8::iterator string8Iterator = eastl::begin(str8);
			EATEST_VERIFY(string8Iterator == eastl::end(str8));
		#endif
	}

	// eastl::data
	{
		eastl::array<int, 0> intArray;
		int* pIntArrayData = eastl::data(intArray);
		EATEST_VERIFY(pIntArrayData == intArray.data());

		eastl::vector<int> intVector;
		int* pIntVectorData = eastl::data(intVector);
		EATEST_VERIFY(pIntVectorData == intVector.data());

		int intCArray[34];
		int* pIntCArray = eastl::data(intCArray);
		EATEST_VERIFY(pIntCArray == intCArray);

		std::initializer_list<int> intInitList;
		const int* pIntInitList = eastl::data(intInitList);
		EATEST_VERIFY(pIntInitList == intInitList.begin());
	}

	// eastl::size
	{
		eastl::vector<int> intVector;
		intVector.push_back();
		intVector.push_back();
		intVector.push_back();
		EATEST_VERIFY(eastl::size(intVector) == 3);

		int intCArray[34];
		EATEST_VERIFY(eastl::size(intCArray) == 34);
		static_assert(eastl::size(intCArray) == 34, "eastl::size failure");
	}

	// eastl::ssize
	{
		eastl::vector<int> intVector;
		intVector.push_back();
		intVector.push_back();
		intVector.push_back();
		EATEST_VERIFY(eastl::ssize(intVector) == (signed)3);

		int intCArray[34];
		EATEST_VERIFY(eastl::ssize(intCArray) == (signed)34);
		static_assert(eastl::ssize(intCArray) == 34, "eastl::ssize failure");
	}

	// eastl::empty
	{
		eastl::vector<int> intVector;
		EATEST_VERIFY(eastl::empty(intVector));
		intVector.push_back();
		EATEST_VERIFY(!eastl::empty(intVector));

		std::initializer_list<int> intInitListEmpty;
		EATEST_VERIFY(eastl::empty(intInitListEmpty));
		EATEST_VERIFY(!eastl::empty({1, 2, 3, 4, 5, 6}));
	}

	// Range-based for loops
	{
		{
			eastl::vector<int> v;
			int I = 0;

			v.push_back(0);
			v.push_back(1);

			for(int i : v)
				EATEST_VERIFY(i == I++);
		}

		{
			eastl::string s8;
			char C = 'a';

			s8.push_back('a');
			s8.push_back('b');

			for(char c : s8)
				EATEST_VERIFY(c == C++);
		}
	}

	EASTL_INTERNAL_DISABLE_DEPRECATED() // '*': was declared deprecated
	{
		// is_iterator_wrapper
		static_assert((eastl


 &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> LabelValue {
        LabelValue::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ClassValue>>(
                    "class_value",
                    |m: &LabelValue| { &m.class_value },
                    |m: &mut LabelValue| { &mut m.class_value },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                    "label_id",
                    |m: &LabelValue| { &m.label_id },
                    |m: &mut LabelValue| { &mut m.label_id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<LabelValue>(
                    "LabelValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static LabelValue {
        static mut instance: ::protobuf::lazy::Lazy<LabelValue> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const LabelValue,
        };
        unsafe {
            instance.get(LabelValue::new)
        }
    }
}

impl ::protobuf::Clear for LabelValue {
    fn clear(&mut self) {
        self.clear_class_value();
        self.clear_label_id();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for LabelValue {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for LabelValue {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PathValue {
    // message fields
    pub class_value: ::protobuf::SingularPtrField<ClassValue>,
    pub label_id_list: ::std::vec::Vec<i32>,
    pub label_value: ::protobuf::RepeatedField<LabelValue>,
    pub path: ::protobuf::RepeatedField<PathValue>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

impl PathValue {
    pub fn new() -> PathValue {


_at_all(mbptr.data(), mbcnt, myoffset,
                                      single_file_per_rank) != mbcnt) {
          std::cout << "### FATAL ERROR in " << __FILE__ << " at line " << __LINE__
                    << std::endl << "CC adm data not read correctly from rst file, "
                    << "restart file is broken." << std::endl;
          exit(EXIT_FAILURE);
        }
        myoffset += data_size;

      // some ranks are finished writing, so use non-collective write
      } else if (m < pm->nmb_thisrank) {
        // get ptr to MeshBlock data
        auto mbptr = Kokkos::subview(ccin, m, Kokkos::ALL, Kokkos::ALL, Kokkos::ALL,
                                     Kokkos::ALL);
        int mbcnt = mbptr.size();
        if (resfile.Read_Reals_at(mbptr.data(), mbcnt, myoffset,
                                      single_file_per_rank) != mbcnt) {
          std::cout << "### FATAL ERROR in " << __FILE__ << " at line " << __LINE__
                    << std::endl << "CC adm data not read correctly from rst file, "
                    << "restart file is broken." << std::endl;
          exit(EXIT_FAILURE);
        }
        myoffset += data_size;
      }
    }
    Kokkos::deep_copy(Kokkos::subview(padm->u_adm, std::make_pair(0,nmb), Kokkos::ALL,
                      Kokkos::ALL, Kokkos::ALL, Kokkos::ALL), ccin);
    offset_myrank += nout1*nout2*nout3*nadm*sizeof(Real);   // adm u_adm
    myoffset = offset_myrank;
  }

  // call problem generator again to re-initialize data, fn ptrs, as needed
  // second argument true since this IS a restart
  CallProblemGenerator(pin, true);

  // Check that user defined BCs were enrolled if needed
  if (user_bcs) {
    if (user_bcs_func == nullptr) {
      std::cout << "### FATAL ERROR in " << __FILE__ << " at line " << __LINE__
                << std::endl << "User BCs specified in <mesh> block, but not enrolled "
                << "during restart by SetProblemData()." << std::endl;
      exit(EXIT_FAILURE);
    }
  }
  // Check that user defined srcterms were enrolled if needed
  if (user_srcs) {
    if (user_srcs_func == nullptr) {
      std::cout << "### FATAL ERROR in " << __FILE__ << " at line " << __LINE__
                << std::endl << "User SRCs specified in <problem> block, but not "
                << "enrolled by UserProblem()." << std::endl;
      exit(EXIT_FAILURE);
    }
  }
  // Check that user defined history outputs were enrolled if needed
  if (user_hist) {
    if (user_hist_func == nullptr) {
      std::cout << "### FATAL ERROR in " << __FILE__ << " at line " << __LINE__
                << std::endl << "User history output specified in <problem> block, "
                << "but not enrolled by UserProblem()." << std::endl;
      exit(EXIT_FAILURE);
    }
  }
}

//-----------------------


}.content-page-topsider{padding:15px 10px;border-bottom:1px solid #DDD;background-color:#f9f9f9}.content-page-topsider i.icon-notice{margin-right:5px}.content-page-body{margin:40px 0 20px}.content-page-bottomsider{padding:25px 10px;margin-top:40px;border-top:1px solid #DDD;height:40px;text-align:center}.content-result{position:relative;width:650px;min-height:330px;margin:30px 0 0 60px;overflow:hidden;border:1px solid #DDD;background-color:#fff;border-radius:4px}.upload-list li{text-align:center;padding:5px 10px;margin:5px 0;height:35px}.upload-list li input[type=text]{width:225px}.upload-list li input[type=file]{width:280px;padding:5px 10px;border:1px solid #DDD;background-color:#f9f9f9;border-radius:4px;color:#45484d}.add-upload-item{margin:0 auto;position:relative;display:inline-block;border-radius:4px;background-color:#f9f9f9;height:28px;line-height:28px;border:1px solid #DDD;color:#45484d;width:300px;cursor:pointer}.add-upload-item:hover{background-color:#E2E6E8;color:#45484d}.add-upload-item:active{background-color:#fff;color:#45484d}.submit-successful-bg{position:absolute;right:0;bottom:0;background:url(../images/member_v2/2333.png) bottom right no-repeat;width:260px;height:190px}.submit-successful{position:absolute;background:url(../images/member_v2/cpt.png) no-repeat;width:280px;height:81px}.filter-list{display:inline-block;margin:10px 0;width:600px}.filter-list-item{line-height:16px;padding:2px 5px;border:1px solid #EEE;border-radius:4px;display:inline-block;*display:inline;*zoom:1;margin:5px 10px 5px 5px;color:#999;position:relative}.filter-list-item i{display:none;position:absolute;margin-top:-10px;top:0;right:0;margin-right:-10px}.filter-list-item:hover{box-shadow:0 0 6px #EEE;color:#999}.control-content-tab-item{float:left;width:60px;height:35px;font-size:13px;line-height:35px;text-align:center;padding:0 5px;background-color:#f9f9f9;border:1px solid #DDD;position:relative}.blue-sign,.pink-sign{color:#fff;padding:2px 15px;font-weight:700}.control-content-tab-item.t-left{border-radius:4px 0 0 4px;border-right:none}.control-content-tab-item.t-right{border-radius:0 4px 4px 0;border-left:none}.control-content-tab-item.on{border:1px solid #2b99ce;color:#fff;background-color:#2b99ce}.control-content-tab-item i{display:none;position:absolute;margin:0;bottom:-10px;left:25px}.control-content-tab-item.on i{display:block}.blue-sign{border:1px solid #207CA9;background:#2D98CE;border-radius:4px}.pink-sign{border:1px solid #BC3764;background:#F35D83;border-radius:4px}.clearfix:after{content:"";display:block;visibility:hidden;height:0;clear:both;font-size:0}.clearfix{zoom:1}.v-middle:after{display:inline-block;width:0;height:100%;content:".";vertical-align:middle;overflow:hidden}.rel{position:relative}.abs{position:absolute}textarea.auto-size{transition:.1s height linear;resize:none;vertical-align:


abel|$projectId|$labelId")
        return client.get(ServicePipelineGroupResource::class).deleteLabel(
            userId = userId,
            projectId = projectId,
            labelId = labelId
        )
    }

    override fun updateLabel(userId: String, projectId: String, pipelineLabel: PipelineLabelUpdate): Result<Boolean> {
        logger.info("OPENAPI_PIPELINE_GROUP_V3|$userId|update label|$projectId|$pipelineLabel")
        return client.get(ServicePipelineGroupResource::class).updateLabel(
            userId = userId,
            projectId = projectId,
            pipelineLabel = pipelineLabel
        )
    }

    companion object {
        private val logger = LoggerFactory.getLogger(ApigwPipelineGroupResourceV3Impl::class.java)
    }
}
/*
 * Tencent is pleased to support the open source community by making BK-CI 蓝鲸持续集成平台 available.
 *
 * Copyright (C) 2019 Tencent.  All rights reserved.
 *
 * BK-CI 蓝鲸持续集成平台 is licensed under the MIT license.
 *
 * A copy of the MIT License is included in this file.
 *
 *
 * Terms of the MIT License:
 * ---------------------------------------------------
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of
 * the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
 * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package com.tencent.devops.openapi.resources.apigw.v3

import com.tencent.devops.artifactory.api.service.ServiceArtifactoryResource
import com.tencent.devops.artifactory.api.service.ServiceLogFileResource
import com.tencent.devops.artifactory.pojo.FileInfo
import com.tencent.devops.artifactory.pojo.SearchProps
import com.tencent.devops.artifactory.pojo.Url
import com.tencent.devops.artifactory.pojo.enums.ArtifactoryType
import com.tencent.devops.common.api.pojo.Page
import com.tencent.devops.common.api.pojo.Result
import com.tencent.devops.common.client.Client
import com.tencent.devops.common.web.RestResource
import com.tencent.devops.openapi.api.apigw.v3.ApigwArtifactoryResourceV3
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired

@RestResource
@Suppress("UNUSED")
class ApigwArtifactoryResourceV3Impl @Autowired constructor(
    private val client: Client
) : ApigwArtifactoryResourceV3 {

    override fun getUserDownloadUrl(
        appCode: String?,
        apigwType: String?,
        userId: String,
        projectId: String,
        artifactoryType: ArtifactoryType,
        path: String
    ): Result<Url> {
        logger.info("OPENAPI_ARTIFACTORY_V3|$userId|get user download url|$projectId|$artifactoryType|$path")
        return client.get(ServiceArtifactoryResource::class).downloadUrlForOpenApi(
            userId = userId,
            projectId = projectId,


rror(t *testing.T) {
	ctx := context.Background()
	client := &fakeClient{predictErr: errors.New("predict failure")}

	_, err := createCodeSampleEmbeddings(ctx, client, "test-proj", "us-central1", "mock-model", "go-sql-driver/mysql_go-sql-spanner")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "predict failure")
}

func TestCreateCodeSampleEmbeddings_InvalidJSON(t *testing.T) {
	ctx := context.Background()
	// Temporarily assign invalid JSON
	oldGoConcept := goMysqlMigrationConcept
	goMysqlMigrationConcept = []byte("invalid json")
	defer func() { goMysqlMigrationConcept = oldGoConcept }()

	client := &fakeClient{}
	_, err := createCodeSampleEmbeddings(ctx, client, "test-proj", "us-central1", "mock-model", "go-sql-driver/mysql_go-sql-spanner")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid character")
}

func TestFakeClient_CloseCalled(t *testing.T) {
	client := &fakeClient{}
	err := client.Close()
	assert.NoError(t, err)
	assert.True(t, client.closeCalled)
}

func TestCreateQueryExampleEmbeddingsWithClient(t *testing.T) {
	oldMysqlQueryExamples := utils.QueryTranslationExamples
	defer func() { utils.QueryTranslationExamples = oldMysqlQueryExamples }()
	utils.QueryTranslationExamples = []byte(`[
		{
			"id": "1",
			"example": "SELECT * FROM employees",
			"rewrite": {
				"theory": "simple select",
				"options": [{"mysql_code": "SELECT * FROM employees", "spanner_code": "SELECT * FROM employees"}]
			}
		}
	]`)
	ctx := context.Background()
	client := &fakeClient{}
	concepts, err := createQuerySampleEmbeddings(ctx, client, "test-proj", "us-central1", "mock-model")
	assert.NoError(t, err)
	assert.Len(t, concepts, 1)
	assert.Equal(t, "1", concepts[0].ID)
	assert.InDeltaSlice(t, []float32{0.1, 0.2, 0.3}, concepts[0].Embedding, 0.001)
}
// Copyright 2020 Google LLC
//
// 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 postgres

import (
	"fmt"
	"math/bits"
	"testing"
	"time"

	"cloud.google.com/go/civil"
	"cloud.google.com/go/spanner"
	"github.com/GoogleCloudPlatform/spanner-migration-tool/internal"
	"github.com/GoogleCloudPlatform/spanner-migration-tool/schema"
	"github.com/GoogleCloudPlatform/spanner-migration-tool/spanner/ddl"
	"github.com/stretchr/testify/assert"
)

// Basic smoke test of ProcessDataRow. The core part of this code path
// (ConvertData) is tested in TestConvertData.
func TestProcessDataRow(t *testing.T) {
	tableName := "testtable"
	table


     "toml",
		},
		auto_install = true,
    sync_install = false,
		highlight = {
			enable = true,
			additional_vim_regex_highlighting = false,
		},
		incremental_selection = {
			enable = true,
			keymaps = {
				init_selection = "<C-s>",
				node_incremental = "<C-s>",
				scope_incremental = "<TAB>",
				node_decremental = "<BS>",
			},
		},
	})
end

return {
	"nvim-treesitter/nvim-treesitter",
  build = ":TSUpdate",
  event = {"BufReadPost", "BufNewFile"},
	lazy = false,
	config = config,
}


;
}
.sett_aff_link span {
	width: 67px;
    height: 67px;
}
.sett_aff_link .form-group {
	    margin: 0;
}
.sett_aff_link .form-group label {

}
.sett_aff_link .form-group input[type=text] {

}

.pt_google_auth {
	display: flex;
    align-items: center;
    justify-content: center;
    gap: 20px;
    flex-wrap: wrap;margin: 20px 0 0;
}
.pt_google_auth img {
	width: 100%;
    max-width: 230px;
    flex: 0 0 auto;border-radius: 10px;
}
.pt_google_auth .form-group {
	flex: 1 1 auto;
    margin: 20px 0;
}

.pt_google_auth_info {
	margin-top: 25px;
}
.pt_google_auth_info p {
	    margin: 17px 0 0;
    font-size: 15px;
    line-height: normal;display: flex;
    align-items: flex-start;
    gap: 15px;
}
.pt_google_auth_info p svg {
	flex: 0 0 auto;
    width: 32px;
    height: 32px;
    background: white;
    padding: 7px;
    border-radius: 5px;
}
.pt_google_auth_info p span {

}

.pt_upgraded_page {
	position: relative;
    text-align: center;
    padding: 100px 0;
}
.pt_upgraded_page > svg:not(.feather) {
	position: absolute;
    height: auto;
    width: 45%;
    left: 50%;
    transform: translateX(-50%);
    top: 100px;
    opacity: 0.3;
}
.pt_upgraded_page > svg.feather {
	margin: 0 0 20px;
    width: auto;
    height: 130px;
    position: relative;animation-duration: 1s;animation-fill-mode: both;
  animation-name: bounce_pro;
}
@keyframes bounce_pro {
  from {
    -webkit-transform: scale3d(1, 1, 1);
    transform: scale3d(1, 1, 1);
  }

  50% {
    -webkit-transform: scale3d(1.05, 1.05, 1.05);
    transform: scale3d(1.05, 1.05, 1.05);
  }

  to {
    -webkit-transform: scale3d(1, 1, 1);
    transform: scale3d(1, 1, 1);
  }
}
.pt_upgraded_page h3 {
	    position: relative;
    font-size: 26px;
}
.pt_upgraded_page p {
	position: relative;
    font-size: 19px;
    max-width: 740px;
    margin: 0 auto 50px;
    line-height: normal;
}
.pt_upgraded_page .btn {
	font-weight: 500;
    border-radius: 2em;
    min-width: 250px;
    padding: 16px 20px;
    font-size: 15px;
}

@media (max-width: 1300px) {
body.mobi_side_open {overflow-y:hidden;}
.new_left_right .left_menu {
	    left: -280px;
    transition: all 0.25s;
    padding: 0;
    bottom: 0;
    top: 0;display: block;width: 280px !important;
}
body.mobi_side_open .new_left_right .left_menu {
	    left: 0;
    z-index: 999;
}
.new_left_right .content_main_wrapper {
	width: 100% !important;
    margin: 0 !important;transition: all 0.25s;
}
body.side_open .new_left_right .content_main_wrapper {
    width: 100% !important;
    margin: 0 !important;
}


RESIS (CM1_CM) × [9.0] ZERO WIDTH JOINER (ZWJ_O_ZWJ_CM) ÷ [0.3]
× 05D0 × 0308 × 0020 ÷ 200D ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] ZERO WIDTH JOINER (ZWJ_O_ZWJ_CM) ÷ [0.3]
× 05D0 × 00A7 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [28.0] SECTION SIGN (AI_AL) ÷ [0.3]
× 05D0 × 0020 ÷ 00A7 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [7.01] SPACE (SP) ÷ [18.0] SECTION SIGN (AI_AL) ÷ [0.3]
× 05D0 × 0308 × 00A7 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [28.0] SECTION SIGN (AI_AL) ÷ [0.3]
× 05D0 × 0308 × 0020 ÷ 00A7 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] SECTION SIGN (AI_AL) ÷ [0.3]
× 05D0 × 50005 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [28.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 05D0 × 0020 ÷ 50005 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [7.01] SPACE (SP) ÷ [18.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 05D0 × 0308 × 50005 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [28.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 05D0 × 0308 × 0020 ÷ 50005 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 05D0 × 0E01 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [28.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 05D0 × 0020 ÷ 0E01 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [7.01] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 05D0 × 0308 × 0E01 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [28.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 05D0 × 0308 × 0020 ÷ 0E01 ÷	#  × [0.3] HEBREW LETTER ALEF (HL) × [9.0] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI


 word);
		}
	}

	/**
	 * Look through the wordnet command-line ouput for a line
	 * that looks like e.g. "Information available for noun dog"
	 * which tells us that "dog" is the singular for "dogs" and
	 * its a noun.
	 */
	private void parseWordnetCommandOutput(String line,
	                                       boolean negativeVerb,
	                                       Morphed m)
	{
		String template = "Information available for ";
		if (line.indexOf(template) != 0)
			return;
		String rest = line.substring(template.length());
		int space = rest.indexOf(" ");
		String cat = rest.substring(0, space);
		if (negativeVerb && !cat.equals("verb"))
			return; // If it's got an n't contraction, and its not
			        // a verb, then I don't know what it is.
		String root = rest.substring(space + 1);
		if (Character.isUpperCase(m.getOriginal().charAt(0))) {
			char[] chars = root.toCharArray();
			chars[0] = Character.toUpperCase(chars[0]);
			root = new String(chars);
		}
		if (cat.equals("noun"))
			m.putRoot(NOUN_F, root);
		else if (cat.equals("verb")) {
			if (negativeVerb)
				m.putRootNegative(VERB_F, root);
			else
				m.putRoot(VERB_F, root);
		} else if (cat.equals("adj"))
			m.putRoot(ADJ_F, root);
		else if (cat.equals("adv"))
			m.putRoot(ADV_F, root);
		else
			throw new RuntimeException("Unknown WordNet category: [" + cat + "] with root [" + root + "]");
	}

	/**
	 * Use the jwnl interfaces to look up a word, straight from
	 * the locally-installed wordnet databases.
	 */
	private void loadLocal(Morphed m)
	{
		String word = m.getOriginal();

		// JWNL has a bug, where it performs a combinatoric explosion
		// of searches for certain words. This is described in
		// sourceforge bug report (see URL):
		// https://sourceforge.net/tracker/?func=detail&aid=3006600&group_id=33824&atid=409470
		// We hack around this here, by skipping any word that has
		// too many dashes in it.
		if (word.length() > 30)
		{
/*
			Actually, just punt on anything longer than 30 letters.
			This should handle just about all comon english words,
			while still avoiding the bug in JWNL.
			int cnt = 0;
			int idx = 0;
			while (0 <= idx)
			{
				idx = word.indexOf('-', idx);
				cnt ++;
				if (cnt > 3) return;
			}
*/
			return;
		}

 		// If it is a common possessive form of personal pronoun,
 		// then don't go any further, we're done.
		if (loadPossessive(word, m))
			return;

		word = stripNegativeContraction(word);
		boolean negativeVerb = !word.equals(m.getOriginal());

		word = convertStandardContraction(word);
		word = convertNounStems(word);

		try {
			Dictionary dict = Dictionary.getInstance();

			/**************
			 * There may be several root forms for any given word. The code
			 * below demonstrates how to look these up in JWNL. Unfortunately
			 * the current design of RelEx assumes that only one root form is
			 * possible, and there's no real way of disambiguating these.
			 *
			 * For example: "men" has the root form "man", of course, but also
			 * "men", because its a synonym for "staff, workforce", in which case
			 * "men" is the correct singular form. This is a rare usage: we can
			 * say "The staff is angry" but not "The men is angry" ...
			 * We will need to hack around this on a case-by-case basis,
			 * unfortunately. :-(
			 *
			 * Note also: W


onParameters parameters)
        {
            this.param = (ElGamalKeyGenerationParameters) parameters;
        }

        public AsymmetricCipherKeyPair GenerateKeyPair()
        {
			DHKeyGeneratorHelper helper = DHKeyGeneratorHelper.Instance;
			ElGamalParameters egp = param.Parameters;
			DHParameters dhp = new DHParameters(egp.P, egp.G, null, 0, egp.L);

			BigInteger x = helper.CalculatePrivate(dhp, param.Random);
			BigInteger y = helper.CalculatePublic(dhp, x);

			return new AsymmetricCipherKeyPair(
                new ElGamalPublicKeyParameters(y, egp),
                new ElGamalPrivateKeyParameters(x, egp));
        }
    }

}
#pragma warning restore
#endif


ake_case)]
fn WLENGTH() -> u16 {
    USBD::borrow_unchecked(|usbd| {
        u16::from(usbd.WLENGTHL.read().bits()) | (u16::from(usbd.WLENGTHH.read().bits()) << 8)
    })
}

fn ep0status() {
    USBD::borrow_unchecked(|usbd| {
        usbd.TASKS_EP0STATUS.write(|w| w.TASKS_EP0STATUS(1));
    });
}

fn suspend() {
    semidap::info!("entering low power mode");
    USBD::borrow_unchecked(|usbd| usbd.LOWPOWER.write(|w| w.LOWPOWER(1)))
}

fn resume() {
    semidap::info!("leaving low power mode");
    USBD::borrow_unchecked(|usbd| usbd.LOWPOWER.zero())
}
<gh_stars>0
// Copyright 2019-2022 Google LLC
//
// 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
//
//     https://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.

//! Combinatorial number system
//!
//! See [wikipedia] for more information.
//!
//! [wikipedia]: https://en.wikipedia.org/wiki/Combinatorial_number_system

#[cfg(feature = "alloc")]
use alloc::vec;
#[cfg(feature = "alloc")]
use alloc::vec::Vec;
use core::borrow::BorrowMut;

/// Writes the combination of a value to a slice.
///
/// The written combination can be encoded with [`encode`] to get back `n`.
///
/// ```rust
/// # use number_encoding::combinadics::{decode_mut, encode};
/// # let n = 5;
/// # let k = 3;
/// let mut xs = vec![0; k];
/// decode_mut(n, k, &mut xs);
/// assert_eq!(encode(&xs), n);
/// ```
///
/// See [`decode`] for a version that allocates a vector for the combination.
///
/// # Panics
///
/// Panics in debug mode if `n > 0 && k == 0`.
pub fn decode_mut(mut n: usize, mut k: usize, r: &mut [usize]) {
    debug_assert_eq!(r.len(), k, "Failed precondition");
    debug_assert!(k > 0 || n == 0, "Failed precondition");
    while k > 0 {
        let mut i = k;
        let mut x = 1;
        while x <= n {
            i += 1;
            x *= i;
            x /= i - k;
        }
        x *= i - k;
        x /= i;
        i -= 1;
        n -= x;
        k -= 1;
        r[k] = i;
    }
}

/// Returns the combination of a value.
///
/// The returned combination can be encoded with [`encode`] to get back `n`.
///
/// ```rust
/// # use number_encoding::combinadics::{decode, encode};
/// let


ool|null}
*/
Elp.Q = function (toolName) {
	// this method is overridden by the tool constructor on specific elements
	return undefined;
};

/**
 * Returns a snapshot of the computed style of an element.
 * @method computedStyle
 * @param {String} [name] If provided, the value of a property is returned instead of the whole style object.
 * @param {String} [pseudoElement] Optionally indicate the pseudo-element ("::before", "::placeholder" etc.) to get the style of
 * @return {Object|String}
 */
Elp.computedStyle = function(name, pseudoElement) {
	var computedStyle = root.getComputedStyle
		? root.getComputedStyle(this, pseudoElement)
		: this.currentStyle;
	var result = {};
	for (var k in computedStyle) {
		var k2 = root.getComputedStyle ? k : k.replace(/-(\w)/gi, function (word, letter) {
			return letter.toUpperCase();
		});
		result[k2] = computedStyle[k];
	}
	return name ? result[name.replace(/-(\w)/gi, function (word, letter) {
		return letter.toUpperCase();
	})] : result;
};

/**
 * Returns the first element in the chain of parent elements which supports scrolling
 * @method scrollingParent
 * @param {Boolean} [skipIfNotOverflowed=false] If element is not overflowed, continue search
 * @param {String} [direction="all"] Can also be "vertical" or "horizontal"
 * @param {Boolean} [includeSelf=false] Whether the element itself can be returned if it matches
 * @return {Element|null} Returns the first parent encountered that matches, otherwise null
 */
Elp.scrollingParent = function(skipIfNotOverflowed, direction, includeSelf) {
	var p = this;
	while (includeSelf ? 1 : (p = p.parentElement)) {
		includeSelf = false;
		if (typeof p.computedStyle !== 'function') {
			continue;
		}
		var pcs = p.computedStyle();
		var overflow;
		if (direction === 'vertical') {
			overflow = pcs.overflowY || p.style.overflowY;
		} else if (direction === 'horizontal') {
			overflow = pcs.overflowX || p.style.overflowX;
		} else {
			overflow = pcs.overflow || p.style.overflow
				|| pcs.overflowY || p.style.overflowY
				|| pcs.overflowX || p.style.overflowX;
		}
		if (overflow && overflow !== 'hidden' && (
			(p === document.documentElement || overflow !== 'visible')
		)) {
			if (!skipIfNotOverflowed || p.clientHeight < p.scrollHeight) {
				return p;
			}
		}
	}
	return p || null;
};

/**
 * Check whether this element has a given CSS class
 * @method hasClass
 * @param {String} className
 * @return {boolean}
 */
Elp.hasClass = function (className) {
	if (this.classList) {
		return this.classList.contains(className);
	} else {
		return new RegExp('(^| )' + className + '( |$)', 'gi').test(this.className);
	}
};

/**
 * Remove a CSS class from the element
 * @method removeClass
 * @chainable
 * @param {String} className
 * @return {Element} returns this, for chaining
 */
Elp.removeClass = function (className) {
	if (this.classList) {
		this.classList.remove(className);
	} else {
		this.className = this.className.replace(new RegExp('(^| )'
			+ className.split(' ').join('|') + '( |$)', 'gi'), ' ');


 The "title" state should be updated if the template title changed.
    if (template) {
      setTitle(template.title);
    }
  }, [template]);
  const closeDialog = shouldUpdate => {
    props.setId(null);
    if (shouldUpdate) {
      updateTemplate(props.id, {
        post_title: title
      });
    }
  };
  if (!props.id) {
    return '';
  }
  return /*#__PURE__*/_react.default.createElement(_appUi.Dialog, {
    title: __('Rename Site Part', 'elementor-pro'),
    approveButtonText: __('Change', 'elementor-pro'),
    onSubmit: () => closeDialog(true),
    approveButtonOnClick: () => closeDialog(true),
    approveButtonColor: "primary",
    dismissButtonText: __('Cancel', 'elementor-pro'),
    dismissButtonOnClick: () => closeDialog(),
    onClose: () => closeDialog()
  }, /*#__PURE__*/_react.default.createElement("input", {
    type: "text",
    className: "eps-input eps-input-text eps-input--block"
    // eslint-disable-next-line jsx-a11y/no-autofocus
    ,
    autoFocus: true,
    value: title,
    onChange: e => setTitle(e.target.value)
  }));
}
DialogRename.propTypes = {
  id: PropTypes.number,
  setId: PropTypes.func.isRequired
};

/***/ }),

/***/ "../core/app/modules/site-editor/assets/js/part-actions/dialogs-and-buttons.js":
/*!*************************************************************************************!*\
  !*** ../core/app/modules/site-editor/assets/js/part-actions/dialogs-and-buttons.js ***!
  \*************************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
/* provided dependency */ var __ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n")["__"];
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");

var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.PartActionsDialogs = PartActionsDialogs;
exports["default"] = PartActionsButtons;
exports.handlers = void 0;
var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
var _dialogRename = _interopRequireDefault(__webpack_require__(/*! ./dialog-rename */ "../core/app/modules/site-editor/assets/js/part-actions/dialog-rename.js"));
var _dialogDelete = _interopRequireDefault(__webpack_require__(/*! ./dialog-delete */ "../core/app/modules/site-editor/assets/js/part-actions/dialog-delete.js"));
var _appUi = __webpack_require__(/*! @elementor/app-ui */ "@elementor/app-ui");
const handlers = exports.handlers = {
  rename: null,
  delete: null
};

// TODO: Think about refactor to portals: https://reactjs.org/docs/portals.html
function PartActionsDialogs() {
  const [DialogRenameId, setDialogRenameId] = _react.default.useState(null);
  const [DialogDeleteId, setDialogDeleteId] = _react.default.useState(null);
  handlers.rename = setDialogRenameId;
  handlers.delete = setDialogDeleteId;
  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_dialogRename.default, {
    id: DialogRenameId,
    set


rebuild"], [511, 2, 1, "", "model_validate"], [511, 2, 1, "", "model_validate_json"], [511, 2, 1, "", "model_validate_strings"], [511, 2, 1, "", "to_str_list"]], "langtest.utils.custom_types.output.TranslationOutput": [[512, 2, 1, "", "__init__"], [512, 2, 1, "", "copy"], [512, 3, 1, "", "model_computed_fields"], [512, 3, 1, "", "model_config"], [512, 2, 1, "", "model_construct"], [512, 2, 1, "", "model_copy"], [512, 2, 1, "", "model_dump"], [512, 2, 1, "", "model_dump_json"], [512, 4, 1, "", "model_extra"], [512, 3, 1, "", "model_fields"], [512, 4, 1, "", "model_fields_set"], [512, 2, 1, "", "model_json_schema"], [512, 2, 1, "", "model_parametrized_name"], [512, 2, 1, "", "model_post_init"], [512, 2, 1, "", "model_rebuild"], [512, 2, 1, "", "model_validate"], [512, 2, 1, "", "model_validate_json"], [512, 2, 1, "", "model_validate_strings"], [512, 2, 1, "", "to_str_list"]], "langtest.utils.custom_types.predictions": [[514, 1, 1, "", "NERPrediction"], [515, 1, 1, "", "SequenceLabel"]], "langtest.utils.custom_types.predictions.NERPrediction": [[514, 2, 1, "", "__init__"], [514, 2, 1, "", "copy"], [514, 3, 1, "", "model_computed_fields"], [514, 3, 1, "", "model_config"], [514, 2, 1, "", "model_construct"], [514, 2, 1, "", "model_copy"], [514, 2, 1, "", "model_dump"], [514, 2, 1, "", "model_dump_json"], [514, 4, 1, "", "model_extra"], [514, 3, 1, "", "model_fields"], [514, 4, 1, "", "model_fields_set"], [514, 2, 1, "", "model_json_schema"], [514, 2, 1, "", "model_parametrized_name"], [514, 2, 1, "", "model_post_init"], [514, 2, 1, "", "model_rebuild"], [514, 2, 1, "", "model_validate"], [514, 2, 1, "", "model_validate_json"], [514, 2, 1, "", "model_validate_strings"]], "langtest.utils.custom_types.predictions.SequenceLabel": [[515, 2, 1, "", "__init__"], [515, 2, 1, "", "copy"], [515, 3, 1, "", "model_computed_fields"], [515, 3, 1, "", "model_config"], [515, 2, 1, "", "model_construct"], [515, 2, 1, "", "model_copy"], [515, 2, 1, "", "model_dump"], [515, 2, 1, "", "model_dump_json"], [515, 4, 1, "", "model_extra"], [515, 3, 1, "", "model_fields"], [515, 4, 1, "", "model_fields_set"], [515, 2, 1, "", "model_json_schema"], [515, 2, 1, "", "model_parametrized_name"], [515, 2, 1, "", "model_post_init"], [515, 2, 1, "", "model_rebuild"], [515, 2, 1, "", "model_validate"], [515, 2, 1, "", "model_validate_json"], [515, 2, 1, "", "model_validate_strings"]], "langtest.utils.custom_types.sample": [[517, 1, 1, "", "AMEGASample"], [518, 1, 1, "", "BaseQASample"], [519, 1, 1, "", "BaseSample"], [520, 1, 1, "", "ClinicalSample"], [521, 1, 1, "", "CrowsPairsSample"]


li r3, 4
/* 803DCCD4 003D8934  4E 80 00 20 */	blr
/* 803DCCD8 003D8938  38 60 00 02 */	li r3, 2
/* 803DCCDC 003D893C  4E 80 00 20 */	blr
/* 803DCCE0 003D8940  38 60 00 0E */	li r3, 0xe
/* 803DCCE4 003D8944  4E 80 00 20 */	blr
/* 803DCCE8 003D8948  38 60 00 06 */	li r3, 6
/* 803DCCEC 003D894C  4E 80 00 20 */	blr
/* 803DCCF0 003D8950  38 60 00 05 */	li r3, 5
/* 803DCCF4 003D8954  4E 80 00 20 */	blr
/* 803DCCF8 003D8958  38 60 00 07 */	li r3, 7
/* 803DCCFC 003D895C  4E 80 00 20 */	blr
/* 803DCD00 003D8960  38 60 00 10 */	li r3, 0x10
/* 803DCD04 003D8964  4E 80 00 20 */	blr
/* 803DCD08 003D8968  38 60 00 11 */	li r3, 0x11
/* 803DCD0C 003D896C  4E 80 00 20 */	blr
/* 803DCD10 003D8970  38 60 00 08 */	li r3, 8
/* 803DCD14 003D8974  4E 80 00 20 */	blr
lbl_803DCD18:
/* 803DCD18 003D8978  38 60 00 00 */	li r3, 0
/* 803DCD1C 003D897C  4E 80 00 20 */	blr

.global func_803DCD20
func_803DCD20:
/* 803DCD20 003D8980  94 21 FF E0 */	stwu r1, -0x20(r1)
/* 803DCD24 003D8984  7C 08 02 A6 */	mflr r0
/* 803DCD28 003D8988  90 01 00 24 */	stw r0, 0x24(r1)
/* 803DCD2C 003D898C  39 61 00 20 */	addi r11, r1, 0x20
/* 803DCD30 003D8990  4B DE A3 F5 */	bl _savegpr_26
/* 803DCD34 003D8994  3F A0 80 64 */	lis r29, lbl_8063CE34@ha
/* 803DCD38 003D8998  3C A0 00 01 */	lis r5, 0x0000FFFF@ha
/* 803DCD3C 003D899C  7C 7A 1B 78 */	mr r26, r3
/* 803DCD40 003D89A0  7C 9B 23 78 */	mr r27, r4
/* 803DCD44 003D89A4  3B BD CE 34 */	addi r29, r29, lbl_8063CE34@l
/* 803DCD48 003D89A8  3B E5 FF FF */	addi r31, r5, 0x0000FFFF@l
/* 803DCD4C 003D89AC  3B 80 00 00 */	li r28, 0
lbl_803DCD50:
/* 803DCD50 003D89B0  7F 44 D3 78 */	mr r4, r26
/* 803DCD54 003D89B4  38 7D 00 48 */	addi r3, r29, 0x48
/* 803DCD58 003D89B8  57 85 06 3E */	clrlwi r5, r28, 0x18
/* 803DCD5C 003D89BC  4B FB 5A C5 */	bl func_80392820
/* 803DCD60


odel_instances = categories[:2] + applications
        grouped_instances = {cls: list(instances) for cls, instances in
                             groupby(model_instances, key=lambda instance: instance.__class__)}
        for cls, instances in grouped_instances.items():
            self.assert_not_cached(get_queryable_property_descriptor(cls, 'version_count'), *instances)
        prefetch_queryable_properties(model_instances, 'version_count')
        for cls, instances in grouped_instances.items():
            self.assert_cached(get_queryable_property_descriptor(cls, 'version_count'), *instances)

    @skip_if_no_composite_pks
    def test_composite_pks(self, django_assert_num_queries, download_links):
        descriptor = get_queryable_property_descriptor(download_links[0].__class__, 'alternative')
        self.assert_not_cached(descriptor, *download_links)
        with django_assert_num_queries(1):
            prefetch_queryable_properties(download_links, 'alternative')
            self.assert_cached(descriptor, *download_links)
            assert download_links[0].alternative == download_links[1]
            assert 'sourceforge' in download_links[0].alternative.url

    @pytest.mark.usefixtures('versions')
    def test_refresh_cache(self):
        """
        Test that prefetch_queryable_properties can be used to update already
        cached values on instances.
        """
        descriptor = get_queryable_property_descriptor(ApplicationWithClassBasedProperties, 'version_count')
        application = ApplicationWithClassBasedProperties.objects.select_properties('version_count')[0]
        self.assert_cached(descriptor, application)
        application.versions.all().delete()
        assert application.version_count > 0  # The cached value is still present
        prefetch_queryable_properties([application], 'version_count')
        self.assert_cached(descriptor, application)

    @pytest.mark.parametrize('property_name, expected_exception', [
        ('non_existent', QueryablePropertyDoesNotExist),
        ('application__non_existent', QueryablePropertyDoesNotExist),
        ('non_existent__non_existent', AttributeError),
    ])
    def test_invalid_propery_path(self, versions, property_name, expected_exception):
        with pytest.raises(expected_exception):
            prefetch_queryable_properties(versions, property_name)


ize;
    if len <= 24 {
        if len <= 12 {
            if len <= 4 {
                return mk_hash32_len_0_to_4(s, 0)
            }
            return mk_hash32_len_5_to_12(s, 0)
        }
        return mk_hask32_len_13_to_24(s, 0)
    }

    // len > 24
    //var h, g, f uint32
    let mut h = len as u32;
    let mut g  = (len as u32).wrapping_mul(C1);
    let mut f: u32 = g;
    let a0 = rotate32(fetch32(&s[len-4..]).wrapping_mul(C1), 17).wrapping_mul(C2);
    let a1 = rotate32(fetch32(&s[len-8..]).wrapping_mul(C1), 17).wrapping_mul(C2);
    let a2 = rotate32(fetch32(&s[len-16..]).wrapping_mul(C1), 17).wrapping_mul(C2);
    let a3 = rotate32(fetch32(&s[len-12..]).wrapping_mul(C1), 17).wrapping_mul(C2);
    let a4 = rotate32(fetch32(&s[len-20..]).wrapping_mul(C1), 17).wrapping_mul(C2);
    h ^= a0;
    h = rotate32(h, 19);
    h = h.wrapping_mul(5).wrapping_add(0xe6546b64);
    h ^= a2;
    h = rotate32(h, 19);
    h = h.wrapping_mul(5).wrapping_add(0xe6546b64);
    g ^= a1;
    g = rotate32(g, 19);
    g = g.wrapping_mul(5).wrapping_add(0xe6546b64);
    g ^= a3;
    g = rotate32(g, 19);
    g = g.wrapping_mul(5).wrapping_add(0xe6546b64);
    f = f.wrapping_add(a4);
    f = rotate32(f, 19).wrapping_add(113);
    let mut iters = ((len - 1) / 20) as u64;
    while iters > 0 {
        let a = fetch32(&s);
        let b = fetch32(&s[4..]);
        let c = fetch32(&s[8..]);
        let d = fetch32(&s[12..]);
        let e = fetch32(&s[16..]);
        h = h.wrapping_add(a);
        g = g.wrapping_add(b);
        f = f.wrapping_add(c);
        h = mur(d, h).wrapping_add(e);
        g = mur(c, g).wrapping_add(a);
        f = mur(b.wrapping_add(e.wrapping_mul(C1)), f).wrapping_add(d);
        f = f.wrapping_add(g);
        g = g.wrapping_add(f);
        s = &s[20..];
        iters-=1;
    }
    g = rotate32(g, 11).wrapping_mul(C1);
    g = rotate32(g, 17).wrapping_mul(C1);
    f = rotate32(f, 11).wrapping_mul(C1);
    f = rotate32(f, 17).wrapping_mul(C1);
    h = rotate32(h.wrapping_add(g), 19);
    h = h.wrapping_mul(5).wrapping_add(0xe6546b64);
    h = rotate32(h, 17).wrapping_mul(C1);
    h = rotate32(h.wrapping_add(f), 19);
    h =  h.wrapping_mul(5).wrapping_add(0xe6546b64);
    h = rotate32(h, 17).wrapping_mul(C1);
    return h
}
#![allow(unused_assignments, unused_variables)]

fn main() {
    // Initialize test constants in a way that cannot be determined at compile time, to ensure
    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
    // dependent conditions.
    let is_true = std::env::args().len() == 1;

    l


ustkey) AS TIME WITH TIME ZONE)) FROM orders", timeTypeUnsupportedError, true);
        //assertQueryFails("SELECT approx_distinct(CAST(from_unixtime(custkey) AS TIME WITH TIME ZONE), 0.023) FROM orders", timeTypeUnsupportedError, true);

        // test short decimal
        assertQuery("SELECT approx_distinct(CAST(custkey AS DECIMAL(18, 0))) FROM orders", "SELECT 990");
        assertQuery("SELECT approx_distinct(CAST(custkey AS DECIMAL(18, 0)), 0.023) FROM orders", "SELECT 990");

        // test long decimal
        assertQuery("SELECT approx_distinct(CAST(custkey AS DECIMAL(25, 20))) FROM orders", "SELECT 1013");
        assertQuery("SELECT approx_distinct(CAST(custkey AS DECIMAL(25, 20)), 0.023) FROM orders", "SELECT 1013");

        // test real
        assertQuery("SELECT approx_distinct(CAST(custkey AS REAL)) FROM orders", "SELECT 982");
        assertQuery("SELECT approx_distinct(CAST(custkey AS REAL), 0.023) FROM orders", "SELECT 982");

        // test bigint
        assertQuery("SELECT approx_distinct(custkey) FROM orders", "SELECT 990");
        assertQuery("SELECT approx_distinct(custkey, 0.023) FROM orders", "SELECT 990");

        // test integer
        assertQuery("SELECT approx_distinct(CAST(custkey AS INTEGER)) FROM orders", "SELECT 1028");
        assertQuery("SELECT approx_distinct(CAST(custkey AS INTEGER), 0.023) FROM orders", "SELECT 1028");

        // test smallint
        assertQuery("SELECT approx_distinct(CAST(custkey AS SMALLINT)) FROM orders", "SELECT 1023");
        assertQuery("SELECT approx_distinct(CAST(custkey AS SMALLINT), 0.023) FROM orders", "SELECT 1023");

        // test tinyint
        assertQuery("SELECT approx_distinct(CAST((custkey % 128) AS TINYINT)) FROM orders", "SELECT 128");
        assertQuery("SELECT approx_distinct(CAST((custkey % 128) AS TINYINT), 0.023) FROM orders", "SELECT 128");

        // test double
        assertQuery("SELECT approx_distinct(CAST(custkey AS DOUBLE)) FROM orders", "SELECT 1014");
        assertQuery("SELECT approx_distinct(CAST(custkey AS DOUBLE), 0.023) FROM orders", "SELECT 1014");

        // test varchar
        assertQuery("SELECT approx_distinct(CAST(custkey AS VARCHAR)) FROM orders", "SELECT 1036");
        assertQuery("SELECT approx_distinct(CAST(custkey AS VARCHAR), 0.023) FROM orders", "SELECT 1036");

        // test char
        String charQuery = "SELECT approx_distinct(CAST(CAST(custkey AS VARCHAR) AS CHAR(20))) FROM orders";
        String charWithErrorQuery = "SELECT approx_distinct(CAST(CAST(custkey AS VARCHAR) AS CHAR(20)), 0.023) FROM orders";
        if (implicitCastCharNToVarchar) {
            assertQuery(charQuery, "SELECT 1036");
            assertQuery(charWithErrorQuery, "SELECT 1036");
        }
        else {
            assertQueryFails(charQuery, charTypeUnsupportedError, true);
            assertQueryFails(charWithErrorQuery, charTypeUnsupportedError, true);
        }

        // test varbinary
        assertQuery("SELECT approx_distinct(to_utf8(CAST(custkey AS VARCHAR))) FROM orders", "SELECT 1036");
        assertQuery("SELECT approx_distinct(to_utf8(CAST(custkey AS VARCHAR)), 0.023) FROM orders", "SELECT 1036");
    }

    /// `sum_data_size_for_stats` returns a different value for `Varchar` and `Varbinary` datatypes in Presto C++, see:
    /// htt


from django.urls import path
from pcbas import views, viewsFiles, viewsBom
from files import views as file_views

# API Requirements:
# - GET by ID
# - GET all
# - POST
# - PUT by ID
# - ARCHIVE (PUT) by ID
# - File Upload

# IMPORTANT: Views included for API should not have the
# check_user_auth_and_app_permission check.
# Instead, use @permission_classes([IsAuthenticated | APIAndProjectAccess])

urlpatterns = [
    ################### GET API #######################
    path('api/v1/pcbas/', views.get_latest_revisions,
         kwargs={"model_type": "pcba"}),  # Tested

    path('api/v1/pcbas/<int:pk>/', views.fetch_single_pcba,
         kwargs={"model_type": "pcba"}),  # Tested

    ################### POST API ######################
    path('api/v1/pcbas/new/', views.create_new_pcba,
         kwargs={"model_type": "pcba"}),  # Tested

    path('api/v1/pcbas/revision/<int:pk>/',
         views.new_revision, kwargs={"model_type": "pcba"}),  # Tested

    ################### PUT API #######################
    path('api/v1/pcbas/update/<int:pk>/', views.edit_pcba,
         kwargs={"model_type": "pcba"}),  # Tested

    path('api/v1/pcbas/fetchByPartNumberRevision/', views.fetch_pcba_by_revision_and_part_number, kwargs={"model_type": "pcba"}),

    ################### ARCHIVE API ###################
    path('api/v1/pcbas/archive/<int:pk>/',
         views.archive_pcba, kwargs={"model_type": "pcba"}),  # Tested

    ################### FILE API ######################
    path('api/v1/pcbas/upload/<int:pcba_id>/',
         viewsFiles.upload_file_to_pcba,
         kwargs={"model_type": "pcba"}),  # Generic file upload

    path('api/v1/pcbas/bom/<int:pcba_id>/',
         viewsBom.upload_pcba_bom,
         kwargs={"model_type": "pcba"}),  # BOM file upload

    path('api/v1/pcbas/thumbnail/<int:pk>/',
         file_views.upload_thumbnail,
         kwargs={"model_type": "pcba"}),  # Thumbnail upload

]


**********************************************************
INPATT		DC.B	0
DIGVOICES	DC.B	0
BREAK		DC.B	0
LOWMASK		DC.B	0
PATTDELTIME	DC.B	0
PATTDELTIME2	DC.B	0
AD		DC.B	3
		EVEN

BREAKPOS	DC.W	0

ADDMOD		DC.L	0
RELOGE		DC.W	0		* SI = 1 ALORS DEJA RELOGE
ADDCURSEQ	DC.L	0		* ADDRESSE DE LA SEQ COURANTE
ADDCURPATT	DC.L	0		*		 PATT
POINTSEQ	DC.B	0		* POINTEUR DANS LA SEQ COURANTE
CURMUS		DC.B	0		* MUSIQUE COURANTE
CURLEN		DC.B	0		* LONGUEUR DE LA ZIC COURANTE
CURLOP		DC.B	0		* BOUCLE
U		DC.B	6
V		DC.B	6

VOID		DC.B	0		* NB DE VOIES DIGITALES RENCONTREES
VOIY		DC.B	0		* NB DE VOIES YAMAHA    RENCONTREES
PERIODE		DC.L	0
LIGNE		DC.L	0

VOICE0		DS.B	66
VOICE1		DS.B	66
VOICE2		DS.B	66
VOICE3		DS.B	66
VOICE4		DS.B	66
VOICE5		DS.B	66
VOICE6		DS.B	66
VOICE7		DS.B	66
VOICE8		DS.B	66
VOICE9		DS.B	66
VOICE10		DS.B	66

SAVE_REGISTER	DCB.L	6
DEB_BUF		DC.L	0
		DC.L	0

MUSDEB
		DS.B	(2004*2*2)/2
MUSFIN		ds.b	20

PIL1		DC.L	FRQ1W,8,VFRQ1W,12
PIL2		DC.L	FRQ2W,10,VFRQ2W,14
PIL3		DC.L	FRQ3W,12,VFRQ3W,16

DPIL1		DC.L	0,NORM_VOL1		* 0 CAR DRUM DU DAC
DPIL2		DC.L	NORM2,NORM_VOL2
DPIL3		DC.L	ADD_,ADD_VOL

NORM_VOL1					* 0 CAR PAS FAIT
NORM2		DC.L	D625R25,6		* DRUM A  6.25
		DC.L	D625R125,6		* DRUM A 12.5
		DC.L	D625R625,6		* DRUM A 25
		DC.L	D125R625,6		* DRUM A 50
NORM_VOL2	DC.L	D625R25_VOL,10
		DC.L	D625R125_VOL,10
		DC.L	D625R625_VOL,10
		DC.L	D125R625_VOL,10
ADD_		DC.L	D625R25_ADD,8
		DC.L	D625R125_ADD,8
		DC.L	D625R625_ADD,8
		DC.L	D125R625_ADD,8
ADD_VOL		DC.L	D625R25_VOL_ADD,12
		DC.L	D625R125_VOL_ADD,12
		DC.L	D625R625_VOL_ADD,12
		DC.L	D125R625_VOL_ADD,12

TABLE_CHOIX	DC.L	FINVBL,FINVBL,CHOIXDRUM,CHOIXDRUM,CHOIXFRQ,CHOIXFRQ,CHOIXFRQ,CHOIXFRQ

FUNK_TABLE	DC.B	0,5,6,7


   + operationsFailedCount
        + ", operationsCompletedCount="
        + operationsCompletedCount
        + ", errors="
        + errors
        + '}';
  }

  public enum BatchOperationState {
    CREATED,
    ACTIVE,
    SUSPENDED,
    CANCELED,
    COMPLETED,
    PARTIALLY_COMPLETED,
    FAILED
  }
}
/*
 * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH under
 * one or more contributor license agreements. See the NOTICE file distributed
 * with this work for additional information regarding copyright ownership.
 * Licensed under the Camunda License 1.0. You may not use this file
 * except in compliance with the Camunda License 1.0.
 */
package io.camunda.webapps.schema.entities.usertask;

import com.fasterxml.jackson.annotation.JsonInclude;
import io.camunda.webapps.schema.entities.ExporterEntity;
import io.camunda.webapps.schema.entities.PartitionedEntity;
import io.camunda.zeebe.protocol.record.value.TenantOwned;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class TaskEntity
    implements ExporterEntity<TaskEntity>, PartitionedEntity<TaskEntity>, TenantOwned {

  private String id;

  private long key;

  private String tenantId = DEFAULT_TENANT_IDENTIFIER;

  private int partitionId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String flowNodeBpmnId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String name;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String flowNodeInstanceId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private OffsetDateTime completionTime;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String processInstanceId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Long position;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private TaskState state;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private OffsetDateTime creationTime;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String bpmnProcessId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String processDefinitionId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String assignee;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String[] candidateGroups;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String[] candidateUsers;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String formKey;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String formId;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Long formVersion;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Boolean isFormEmbedded;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private OffsetDateTime followUpDate;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private OffsetDateTime dueDate;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String externalFormReference;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Integer processDefinitionVersion;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Map<String, String> customHeaders;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private Integer priority;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private String action;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private List<String> changedAttributes;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private TaskJoinRelationship join;

  @JsonInclude(JsonInclude.Include.NON_NULL)
  private TaskImplementation implementation;

  public TaskEntity()


StateZip.Fields.Store");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.Store.Hint");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.Country");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.Country.Hint");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.StateProvince");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.StateProvince.Hint");
            await this.DeletePluginLocaleResource(_localizationService, _languageService, "Plugins.Tax.CountryStateZip.Fields.Zip");
            await this.DeletePluginLocaleResource(_localizationService, _languageS


using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;

namespace Smartstore.Core.Localization.Routing
{
    [Obsolete("Changed the way localized route matching works")]
    public class CultureRouteConstraint : IRouteConstraint
    {
        const string GlobalMatchKey = "CultureRoutesEnabled";

        public bool Match(
            HttpContext httpContext,
            IRouter route,
            string routeKey,
            RouteValueDictionary values,
            RouteDirection routeDirection)
        {
            var cultureCode = (string)values.Get(routeKey);

            if (cultureCode.IsEmpty())
            {
                return false;
            }

            if (routeDirection == RouteDirection.UrlGeneration)
            {
                // Don't validate. SmartLinkGenerator will handle url gene