S线程和主线程的掉帧所影响。

举一个需要使用这项功能的例子：比如需要给一个模态框做动画（从下往上划动，并在半透明遮罩中淡入），而这个模态框正在初始化，并且可能响应着几个网络请求，渲染着页面的内容，并且还在更新着打开这个模态框的父页面。了解更多有关如何使用LayoutAnimation的信息，请查看[动画指南](/docs/animations.html)。

注意：

 - `LayoutAnimation`只工作在“一次性”的动画上（"静态"动画） -- 如果动画可能会被中途取消，你还是需要使用`Animated`。

### 在屏幕上移动视图（滚动，切换，旋转）时，UI线程掉帧

当具有透明背景的文本位于一张图片上时，或者在每帧重绘视图时需要用到透明合成的任何其他情况下，这种现象尤为明显。设置`shouldRasterizeIOS`或者`renderToHardwareTextureAndroid`属性可以显著改善这一现象。
注意不要过度使用该特性，否则你的内存使用量将会飞涨。在使用时，要评估你的性能和内存使用情况。如果你没有需要移动这个视图的需求，请关闭这一属性。

### 使用动画改变图片的尺寸时，UI线程掉帧

在iOS上，每次调整Image组件的宽度或者高度，都需要重新裁剪和缩放原始图片。这个操作开销会非常大，尤其是大的图片。比起直接修改尺寸，更好的方案是使用`transform: [{scale}]`的样式属性来改变尺寸。比如当你点击一个图片，要将它放大到全屏的时候，就可以使用这个属性。

### Touchable系列组件不能很好的响应

有些时候，如果我们有一项操作与点击事件所带来的透明度改变或者高亮效果发生在同一帧中，那么有可能在`onPress`函数结束之前我们都看不到这些效果。比如在`onPress`执行了一个`setState`的操作，这个操作需要大量计算工作并且导致了掉帧。对此的一个解决方案是将`onPress`处理函数中的操作封装到`requestAnimationFrame`中：

```javascript
handleOnPress() {
  // 谨记在使用requestAnimationFrame、setTimeout以及setInterval时
  // 要使用TimerMixin（其作用是在组件unmount时，清除所有定时器）
  this.requestAnimationFrame(() => {
    this.doExpensiveAction();
  });
}
```

## 分析

你可以利用内置的分析器来同时获取JavaScript线程和主线程中代码执行情况的详细信息。

对于iOS来说，Instruments是一个宝


// Copyright (c) BeiYinZhiNian (1031622947@qq.com). All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
// Website: http://www.caviar.wang/ or https://gitee.com/Cherryblossoms/caviar.

using System.Net;
using System.Threading.Tasks;
using Caviar.SharedKernel.Entities;
using Caviar.SharedKernel.Entities.User;

namespace Caviar.AntDesignUI.Core
{
    public class WasmAuthService : IAuthService
    {
        private readonly HttpService _httpHelper;

        public WasmAuthService(HttpService httpClient)
        {
            this._httpHelper = httpClient;
        }

        public async Task<


				return ((ChartInstance)base.ReportItemInstance).DataPointSeriesCount;
			}
		}

		public int CategoriesCount => ((Microsoft.ReportingServices.ReportProcessing.Chart)base.ReportItemDef).StaticCategoryCount;

		public int SeriesCount => ((Microsoft.ReportingServices.ReportProcessing.Chart)base.ReportItemDef).StaticSeriesCount;

		public override bool NoRows
		{
			get
			{
				if (base.ReportItemInstance == null || ((ChartInstance)base.ReportItemInstance).DataPointSeriesCount == 0 || ((ChartInstance)base.ReportItemInstance).DataPointCategoryCount == 0)
				{
					return true;
				}
				return false;
			}
		}

		internal ChartDataPointInstancesList DataPoints => ((ChartInstance)base.ReportItemInstance).DataPoints;

		internal int CategoryGroupingLevels
		{
			get
			{
				if (m_categoryGroupingLevels == 0)
				{
					m_categoryGroupingLevels = 1;
					ChartHeading chartHeading = ((Microsoft.ReportingServices.ReportProcessing.Chart)base.ReportItemDef).Columns;
					Global.Tracer.Assert(chartHeading != null);
					while (chartHeading.SubHeading != null)
					{
						chartHeading = chartHeading.SubHeading;
						m_categoryGroupingLevels++;
					}
				}
				return m_categoryGroupingLevels;
			}
		}

		internal override string InstanceInfoNoRowMessage
		{
			get
			{
				if (base.InstanceInfo != null)
				{
					return ((ChartInstanceInfo)base.InstanceInfo).NoRows;
				}
				return null;
			}
		}

		internal ImageMapAreasCollection[] DataPointMapAreas
		{
			get
			{
				if (m_imageMapAreaCollection == null)
				{
					RenderChartImageMap();
				}
				return m_imageMapAreaCollection;
			}
		}

		internal float ScaleX
		{
			get
			{
				return m_scaleX;
			}
			set
			{
				m_scaleX = value;
			}
		}

		internal float ScaleY
		{
			get
			{
				return m_scaleY;
			}
			set
			{
				m_scaleY = value;
			}
		}

		internal Chart(int intUniqueName, Microsoft.ReportingServices.ReportProcessing.Chart reportItemDef, ChartInstance reportItemInstance, RenderingContext renderingContext)
			: base(intUniqueName, reportItemDef, reportItemInstance, renderingContext)
		{
		}

		public void SetDpi(int xDpi, int yDpi)
		{
			if (xDpi > 0 && xDpi != 96)
			{
				m_scaleX = (float)xDpi / 96f;
			}
			if (yDpi > 0 && yDpi != 96)
			{
				m_scaleY = (float)yDpi / 96f;
			}
		}

		public MemoryStream GetImage(out bool hasImageMap)
		{
			return GetImage(ImageType.PNG, out hasImageMap);
		}

		public MemoryStream GetImage()
		{
			bool hasImageMap;
			return GetImage(ImageType.PNG, out hasImageMap);
		}

		public MemoryStream GetImage(ImageType type)
		{
			bool hasImageMap;
			return GetImage(type, out hasImageMap);
		}

		public MemoryStream GetImage(ImageType type, out bool hasImageMap)
		{
			hasImageMap = false;
			return null;
		}

		private bool RenderChartImageMap()
		{
			return m_imageMapAreaCollection != null;
		}
	}
}


return file_proto_google_fhir_proto_r4_core_valuesets_proto_rawDescGZIP(), []int{19, 0}
}

type SystemRestfulInteractionValueSet_Value int32

const (
	SystemRestfulInteractionValueSet_INVALID_UNINITIALIZED SystemRestfulInteractionValueSet_Value = 0
	SystemRestfulInteractionValueSet_TRANSACTION           SystemRestfulInteractionValueSet_Value = 1
	SystemRestfulInteractionValueSet_BATCH                 SystemRestfulInteractionValueSet_Value = 2
	SystemRestfulInteractionValueSet_SEARCH_SYSTEM         SystemRestfulInteractionValueSet_Value = 3
	SystemRestfulInteractionValueSet_HISTORY_SYSTEM        SystemRestfulInteractionValueSet_Value = 4
)

// Enum value maps for SystemRestfulInteractionValueSet_Value.
var (
	SystemRestfulInteractionValueSet_Value_name = map[int32]string{
		0: "INVALID_UNINITIALIZED",
		1: "TRANSACTION",
		2: "BATCH",
		3: "SEARCH_SYSTEM",
		4: "HISTORY_SYSTEM",
	}
	SystemRestfulInteractionValueSet_Value_value = map[string]int32{
		"INVALID_UNINITIALIZED": 0,
		"TRANSACTION":           1,
		"BATCH":                 2,
		"SEARCH_SYSTEM":         3,
		"HISTORY_SYSTEM":        4,
	}
)

func (x SystemRestfulInteractionValueSet_Value) Enum() *SystemRestfulInteractionValueSet_Value {
	p := new(SystemRestfulInteractionValueSet_Value)
	*p = x
	return p
}

func (x SystemRestfulInteractionValueSet_Value) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (SystemRestfulInteractionValueSet_Value) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_google_fhir_proto_r4_core_valuesets_proto_enumTypes[20].Descriptor()
}

func (SystemRestfulInteractionValueSet_Value) Type() protoreflect.EnumType {
	return &file_proto_google_fhir_proto_r4_core_valuesets_proto_enumTypes[20]
}

func (x SystemRestfulInteractionValueSet_Value) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use SystemRestfulInteractionValueSet_Value.Descriptor instead.
func (SystemRestfulInteractionValueSet_Value) EnumDescriptor() ([]byte, []int) {
	return file_proto_google_fhir_proto_r4_core_valuesets_proto_rawDescGZIP(), []int{20, 0}
}

type TaskIntentValueSet_Value int32

const (
	TaskIntentValueSet_INVALID_UNINITIALIZED TaskIntentValueSet_Value = 0
	TaskIntentValueSet_UNKNOWN               TaskIntentValueSet_Value = 1
	TaskIntentValueSet_PROPOSAL              TaskIntentValueSet_Value = 2
	TaskIntentValueSet_PLAN                  TaskIntentValueSet_Value = 3
	TaskIntentValueSet_ORDER                 TaskIntentValueSet_Value = 4
	TaskIntentValueSet_ORIGINAL_ORDER        TaskIntentValueSet_Value = 5
	TaskIntentValueSet_REFLEX_ORDER          TaskIntentValueSet_Value = 6
	TaskIntentValueSet_FILLER_ORDER          TaskIntentValueSet_Value = 7
	TaskIntentValueSet_INSTANCE_ORDER        TaskIntentValueSet_Value = 8
	TaskIntentValueSet_OPTION                TaskIntentValueSet_Value = 9
)

// Enum value maps for TaskIntentValueSet_Value.
var (
	TaskIntentValueSet_Value_name = map[int32]string{
		0: "INVALID_UNINITIALIZED",
		1: "UNKNOWN",
		2: "P


或制表符）数量不会引起任何人的不满，那么我们可能会得到一个令人震惊的教训。看似微不足道的格式化决策或编码实践可能会引起激烈的辩论。希望，通过采用有偏见的格式化工具，如使用 Python 时的 black 和在使用 SonarLint 时的代码检查器，许多问题已经得到了解决。

我们可能会发现，在金融科技领域用 COBOL 或 RPG 等语言编写的遗留软件受到 80 或 132 个字符行长的限制，在某些版本中，还需要在特定列（特别是 COBOL）中开始代码。类似的限制也存在于 RPG 和其他早期语言中。虽然现代语言在很大程度上已经摆脱了这些类型的限制，但开发者很快意识到可能自由度太大。今天，许多编程语言都有各种格式化工具，这些工具强制我们的代码遵循为该语言开发的标准。无论是 Perl（perltidy）、Go（gofmt）、JavaScript（Prettier）还是 Python（black），格式化工具都是我们在开始学习新语言时应立即调查的工具。

Linters 通过确保我们的代码保持清洁并避免常见的语言陷阱（例如识别未使用的导入、未使用的变量、无效的比较和有问题的类型转换等）来发挥类似的作用。SonarLint 是一种流行的 linters，适用于许多语言和 IDE。它还提供了与 SonarQube 的集成，这是一个帮助识别和管理问题的产品。其他 linters 也可用，例如在处理 JavaScript 或 TypeScript 时使用的 ESLint。

格式化工具和 linters 可以集成到您的 IDE 中，或者通过 IDE 中的插件提供。因此，开始使用它们并不是一件麻烦事。然而，请确保您使用的是团队批准的工具，并且配置正确。这些工具还可以帮助我们成为更好的程序员，因为它们经常告诉我们为什么这是最佳实践以及如何避免它。我们经常发现自己正在阅读为什么 SonarLint 标记了某些内容，或者查找有关最佳实践的额外示例或更多信息，因为 linters 标记了某些内容。

## 2.4 自动化测试

无论我们是手动编写解析 ACH 文件的初始脚本，还是使用生成式 AI 工具开始，我们都希望确保我们正在使用单元测试。我们更喜欢 TDD 方法，


6Zui
// SIG // nM9aVu2Qqg0NutD3Y9ZKvwECBmjCukj2gxgTMjAyNTEw
// SIG // MDIxNzA3MjIuMjA4WjAEgAIB9KCB0aSBzjCByzELMAkG
// SIG // A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAO
// SIG // BgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m
// SIG // dCBDb3Jwb3JhdGlvbjElMCMGA1UECxMcTWljcm9zb2Z0
// SIG // IEFtZXJpY2EgT3BlcmF0aW9uczEnMCUGA1UECxMeblNo
// SIG // aWVsZCBUU1MgRVNOOkE0MDAtMDVFMC1EOTQ3MSUwIwYD
// SIG // VQQDExxNaWNyb3NvZnQgVGltZS1TdGFtcCBTZXJ2aWNl
// SIG // oIIR6jCCByAwggUIoAMCAQICEzMAAAICeVB0IRR9uKEA
// SIG // AQAAAgIwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UEBhMC
// SIG // VVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcT
// SIG // B1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw
// SIG // b3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUt
// SIG // U3RhbXAgUENBIDIwMTAwHhcNMjUwMTMwMTk0MjQ0WhcN
// SIG // MjYwNDIyMTk0MjQ0WjCByzELMAkGA1UEBhMCVVMxEzAR
// SIG // BgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1v
// SIG // bmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv
// SIG // bjElMCMGA1UECxMcTWljcm9zb2Z0IEFtZXJpY2EgT3Bl
// SIG // cmF0aW9uczEnMCUGA1UECxMeblNoaWVsZCBUU1MgRVNO
// SIG // OkE0MDAtMDVFMC1EOTQ3MSUwIwYDVQQDExxNaWNyb3Nv
// SIG // ZnQgVGltZS1TdGFtcCBTZXJ2aWNlMIICIjANBgkqhkiG
// SIG // 9w0BAQEFAAOCAg8AMIICCgKCAgEAt3kqenLnFBjpHD4O
// SIG // LyliiXxEHrIStmQbGFNbQ1r0Lui/ZafnZ6q2oyHTXh9R
// SIG // zd6M94ohqCVrjdh1TWZHDrd/GlhnmzNIFFDrT47i4bju
// SIG // Xeu2KULBwSQFoXL3vzFXaED49Z44gI0ojqy/MRWqxSyO
// SIG // OkR/DXg4QD13CaVp+wCMwsiI2Tmidg1gPukMDc8KowYC
// SIG // KX9YVhcKh7zxHnctJ6LV27Vn0/bwki/bHQyuivxx/R7G
// SIG // mOcC5lFAe0n7ixqNTlhJujCchto4saovTckaMqXRf


 z,
          y);
        };
      }
      else
      {
        h$p4(n, a, i, h$$bjw);
        h$l8(i[n], ((g + 4) | 0), b, d, e, f, c,
        h$ghcjszmbasezm0zi2zi0zi0zmJozzYZZ7GHc7JEfhDrWZZm3NTZCGHCJSziMarshalzizdwpolyzugo1);
        return h$ap_gen_fast(1800);
      };
      break;
    case (3):
      var A = a.d1;
      var B = a.d2;
      var C = B.d1;
      var D = B.d2;
      h$sp += 10;
      h$stack[(h$sp - 3)] = a;
      h$stack[(h$sp - 2)] = D;
      h$stack[(h$sp - 1)] = A;
      h$stack[h$sp] = h$$bjx;
      return h$e(C);
    case (4):
      var E = a.d1;
      var F = ((c >>> g) | 0);
      var G = (F & 15);
      h$p4(G, a, E, h$$bjw);
      h$l8(E[G], ((g + 4) | 0), b, d, e, f, c,
      h$ghcjszmbasezm0zi2zi0zi0zmJozzYZZ7GHc7JEfhDrWZZm3NTZCGHCJSziMarshalzizdwpolyzugo1);
      return h$ap_gen_fast(1800);
    default:
      var H = a.d1;
      var I = a.d2;
      var J = ((c === H) ? 1 : 0);
      if((J === 1))
      {
        h$p2(c, h$$bju);
        h$l7(I, b, d, e, f, h$$bkO,
        h$ghcjszmbasezm0zi2zi0zi0zmJozzYZZ7GHc7JEfhDrWZZm3NTZCGHCJSziMarshalzizdwzdszdwupdateOrSnocWithKey);
        return h$ap_gen_fast(1542);
      }
      else
      {
        var K = new Array(1);
        for(var L = 0;(L < 1);(L++)) {
          K[L] = a;
        };
        K.m = 0;
        K.__ghcjsArray = true;
        h$pp192(H, h$$bjv);
        return h$e(h$c1(h$baseZCGHCziMVarziMVar_con_e, K));
      };
  };
  return h$rs();
};
function h$ghcjszmbasezm0zi2zi0zi0zmJozzYZZ7GHc7JEfhDrWZZm3NTZCGHCJSziMarshalzizdwpolyzugo1_e()
{
  h$p7(h$r6, h$r2, h$r5, h$r4, h$r3, h$r7, h$$bjt);
  return h$e(h$r8);
};
function h$$bjE()
{
  var a = h$r1.d1;
  var b = h$r1.d2;
  var c = b.d1;
  var d = b.d2;
  var e = b.d3;
  h$l6(a, c, b.d4, e, d, h$ghcjszmbasezm0zi2zi0zi0zmJozzYZZ7GHc7JEfhDrWZZm3NTZCGHCJSziMarshalzizdwzdsunsafeInsert);
  return h$ap_gen_fast(1285);
};
function h$$bjD()
{
  var a = h$r1;
  var b = h$stack[(h$sp - 3)];
  var c = h$stack[(h$sp - 2)];
  var d = h$stack[(h$sp - 1)];
  h$sp -= 4;
  var e = a.d1;
  var f = a.d2;
  var g = f.d1;
  h$l3(h$c5(h$$bjE, b, d,


		},
		oxy_type = {
			1
		},
		search_condition = {
			1
		},
		precast_param = {}
	}
	uv0.weapon_property_346[999995] = {
		action_index = "attack",
		range = 80,
		type = 1,
		fire_fx = "CLFire",
		recover_time = 0,
		axis_angle = 0,
		shakescreen = 0,
		name = "bilibili干杯弹幕",
		aim_type = 0,
		torpedo_ammo = 0,
		expose = 0,
		angle = 180,
		charge_param = "",
		damage = 10,
		corrected = 100,
		min_range = 0,
		id = 999995,
		attack_attribute_ratio = 100,
		fire_fx_loop_type = 1,
		attack_attribute = 1,
		reload_max = 20,
		queue = 1,
		search_type = 1,
		effect_move = 0,
		suppress = 0,
		spawn_bound = "cannon",
		fire_sfx = "battle/cannon-main",
		auto_aftercast = 0,
		initial_over_heat = 0,
		bullet_ID = {
			999100,
			999101,
			999102,
			999103,
			999104,
			999105,
			999106,
			999107,
			999108,
			999200,
			999201,
			999202,
			999203,
			999204,
			999205,
			999206,
			999207,
			999208,
			999300,
			999301,
			999302,
			999303,
			999304,
			999305,
			999306,
			999307,
			999308,
			999400,
			999401,
			999402,
			999403,
			999404,
			999405
		},
		barrage_ID = {
			999500,
			999501,
			999502,
			999503,
			999504,
			999505,
			999506,
			999507,
			999508,
			999600,
			999601,
			999602,
			999603,
			999604,
			999605,
			999606,
			999607,
			999608,
			999700,
			999701,
			999702,
			999703,
			999704,
			999705,
			999706,
			999707,
			999708,
			999800,
			999801,
			999802,
			999803,
			999804,
			999805
		},
		oxy_type = {
			1
		},
		search_condition = {
			1
		},
		precast_param = {}
	}
	uv0.weapon_property_346[999996] = {
		action_index = "attack",
		range = 150,
		type = 1,
		fire_fx = "CAFire",
		recover_time = 0,
		axis_angle = 0,
		shakescreen = 0,
		name = "测试武器3号",
		aim_type = 1,
		torpedo_ammo = 0,
		expose = 0,
		angle = 40,
		charge_param = "",
		damage = 40,
		corrected = 100,
		min_range = 75,
		id = 999996,
		attack_attribute_ratio = 100,
		fire_fx_loop_type = 1,
		attack_attribute = 1,
		reload_max = 2400,
		queue = 1,
		search_type = 1,
		effect_move = 0,
		suppress = 1,
		spawn_bound = "cannon",
		fire_sfx = "battle/cannon-main",
		auto_aftercast = 0,
		initial_over_heat = 0,
		bullet_ID


 1] = p.y;
                    buff[i * 3 + 2] = p.z;
                }
                res.put(0, 0, buff);
            }
                break;

            default:
                throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
            }
        } else {
            res = new Mat();
        }
        return res;
    }

    public static void Mat_to_vector_Point2f(Mat m, List<Point> pts) {
        Mat_to_vector_Point(m, pts);
    }

    public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) {
        Mat_to_vector_Point(m, pts);
    }

    public static void Mat_to_vector_Point(Mat m, List<Point> pts) {
        if (pts == null)
            throw new IllegalArgumentException("Output List can't be null");
        int count = m.rows();
        int type = m.type();
        if (m.cols() != 1)
            throw new IllegalArgumentException("Input Mat should have one column\n" + m);

        pts.clear();
        if (type == CvType.CV_32SC2) {
            int[] buff = new int[2 * count];
            m.get(0, 0, buff);
            for (int i = 0; i < count; i++) {
                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
            }
        } else if (type == CvType.CV_32FC2) {
            float[] buff = new float[2 * count];
            m.get(0, 0, buff);
            for (int i = 0; i < count; i++) {
                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
            }
        } else if (type == CvType.CV_64FC2) {
            double[] buff = new double[2 * count];
            m.get(0, 0, buff);
            for (int i = 0; i < count; i++) {
                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
            }
        } else {
            throw new IllegalArgumentException(
                    "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m);
        }
    }

    public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) {
        Mat_to_vector_Point3(m, pts);
    }

    public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) {
        Mat_to_vector_Point3(m, pts);
    }

    public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) {
        Mat_to_vector_Point3(m, pts);
    }

    public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) {
        if (pts == null)
            throw new IllegalArgumentException("Output List can't be null");
        int count = m.rows();
        int type = m.type();
        if (m.cols() != 1)
            throw new IllegalArgumentException("Input Mat should have one column\n" + m);

        pts.clear();
        if (type == CvType.CV_32SC3) {
            int[] buff = new int[3 * count];
            m.get(0, 0, buff);
            for (int i = 0; i < count; i++) {
                pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
            }
        } else if (type == CvType.CV_32FC3) {
            float[] buff = new float[3 * count];
            m.get(0, 0, buff);
            for (int i = 0; i < count; i++) {


reate(e.signature)}return e.create=function(t){return t instanceof e?t:new e(t)},e.fromJSON=function(t){var n={sender:f.fromJSON(t.sender),sequenceNumber:t.sequence_number,maxGasAmount:t.max_gas_amount,gasUnitPrice:t.gas_unit_price,expirationTimestampSecs:t.expiration_timestamp_secs,payload:Bt.fromJSON(t.payload),signature:Ft.fromJSON(t.signature)};return e.create(n)},e.prototype.toJSON=function(){return{sender:this.sender.toJSON(),sequence_number:this.sequenceNumber,max_gas_amount:this.maxGasAmount,gas_unit_price:this.gasUnitPrice,expiration_timestamp_secs:this.expirationTimestampSecs,payload:Bt.toJSON(this.payload),signature:Ft.toJSON(this.signature)}},e}(),jt={operationId:"submitTransaction",groupName:"transactions",httpMethod:"post",routePattern:"/transactions",parameterNames:["network"],hasResponse:!0,hasBody:!0,parseResponse:function(e){return rt.fromJSON(e)},serializeRequest:function(e){var t=e.network?b.create(e.network):void 0;return{network:t?t.toJSON():void 0}},serializeBody:function(e){var t=Ut.create(e);return t.toJSON()}},qt=function(){function e(){}return e.create=function(e){if(rt.isInput(e))return rt.create(e);if(Tt.isInput(e))return Tt.create(e);if(xt.isInput(e))return xt.create(e);if(It.isInput(e))return It.create(e);if(Mt.isInput(e))return Mt.create(e);throw new Error("Cannot resolve union from AptosGetTransactionByHashInput")},e.fromJSON=function(e){if(rt.isJSON(e))return rt.fromJSON(e);if(Tt.isJSON(e))return Tt.fromJSON(e);if(xt.isJSON(e))return xt.fromJSON(e);if(It.isJSON(e))return It.fromJSON(e);if(Mt.isJSON(e))return Mt.fromJSON(e);var t=Object.keys(e).join(", "),n=e.type;throw new Error("Cannot resolve union from AptosGetTransactionByHashJSON (keys: ".concat(t,", type: ").concat(n,")"))},e.toJSON=function(e){if(e instanceof rt)return e.toJSON();if(e instanceof Tt)return e.toJSON();if(e instanceof xt)return e.toJSON();if(e instanceof It)return e.toJSON();if(e instanceof Mt)return e.toJSON();throw new Error("Cannot resolve union from AptosGetTransactionByHashValue")},e}(),Ht={operationId:"getTransactionByHash",groupName:"transactions",httpMethod:"get",routePattern:"/transactions/by_hash/{txn_hash}",parameterNames:["txn_hash","network"],hasResponse:!0,hasBody:!1,parseResponse:function(e){return qt.fromJSON(e)},serializeRequest:function(e){var t=e.txnHash,n=e.network?b.create(e.network):void 0;return{txn_hash:t,network:n?n.toJSON():void 0}}},Gt=function(){function e(){}return e.create=function(e){if(rt.isInput(e))return rt.create(e);if(Tt.isInput(e))return Tt.create(e);if(xt.isInput(e))return xt.create(e);if(It.isInput(e))return It.create(e);if(Mt.isInput(e))return Mt.create(e);throw new Error("Cannot resolve union from AptosGetTransactionByVersionInput")},e.fromJSON=function(e){if(rt.isJSON(e))return rt.fromJSON(e);if(Tt.isJSON(e))return Tt.fromJSON(e);if(xt.isJSON(e))


					"12": "y",
					"13": "y",
					"14": "y",
					"15": "y",
					"16": "y",
					"17": "y",
					"18": "y",
					"19": "y",
					"20": "y",
					"21": "y",
					"22": "y",
					"23": "y",
					"24": "y",
					"25": "y",
					"26": "y",
					"27": "y"
				},
				"chrome": {
					"4": "n",
					"5": "n",
					"6": "y",
					"7": "y",
					"8": "y",
					"9": "y",
					"10": "y",
					"11": "y",
					"12": "y",
					"13": "y",
					"14": "y",
					"15": "y",
					"16": "y",
					"17": "y",
					"18": "y",
					"19": "y",
					"20": "y",
					"21": "y",
					"22": "y",
					"23": "y",
					"24": "y",
					"25": "y",
					"26": "y",
					"27": "y",
					"28": "y",
					"29": "y",
					"30": "y",
					"31": "y",
					"32": "y"
				},
				"safari": {
					"3.1": "n",
					"3.2": "p",
					"4": "p",
					"5": "p",
					"5.1": "p",
					"6": "p",
					"6.1": "p",
					"7": "p"
				},
				"opera": {
					"9": "n",
					"9.5-9.6": "n",
					"10.0-10.1": "n",
					"10.5": "n",
					"10.6": "y",
					"11": "y",
					"11.1": "y",
					"11.5": "y",
					"11.6": "y",
					"12": "y",
					"12.1": "y",
					"15": "y",
					"16": "y",
					"17": "y",
					"18": "y"
				},
				"ios_saf": {
					"3.2": "n",
					"4.0-4.1": "n",
					"4.2-4.3": "n",
					"5.0-5.1": "n",
					"6.0-6.1": "n",
					"7.0": "n"
				},
				"op_mini": {
					"5.0-7.0": "n"
				},
				"android": {
					"2.1": "n",
					"2.2": "n",
					"2.3": "y",
					"3": "y",
					"4": "y",
					"4.1": "y",
					"4.2-4.3": "y",
					"4.4": "y"
				},
				"bb": {
					"7": "n",
					"10": "n"
				},
				"op_mob": {
					"10": "n",
					"11": "n",
					"11.1": "n",
					"11.5": "n",
					"12": "n",
					"12.1": "n",
					"0": "y"
				},
				"and_chr": {
					"0": "y"
				},
				"and_ff": {
					"0": "y"
				},
				"ie_mob": {
					"10": "p"
				}
			},
			"notes": "Will work in IE9+ and Safari/MacOSX provided the user has the WebM codecs installed.",
			"usage_perc_y": 55.72,
			"usage_perc_a": 0,
			"ucprefix": false,
			"parent": "video",
			"keywords": "matroska"
		},
		"mpeg


don kizárják a Bitcoin-közösségekben való részvételből, csak azért, mert nem feleltek meg a közmegegyezéses retorikának, és kérdéseket mertek feltenni.
\n\n
Ezek a megfáradt utazók újra és újra visszatalálnak a Monerohoz, és miután időt töltöttek a közösségben, dicsérni szokták a projektet a kiegyensúlyozott vitákért és a kényelmetlen kérdésekkel való szembenézésért. Nem példátlan, hogy ezek az utazók más kriptopénzekról akarnak beszélni, nem azért, mert népszerűsíteni akarják, hanem mert bízni kezdtek a közösség értelmében és logikájában, és őszinte véleményeket szeretnének hallani egy másik láncról, amit nem tudnak az ottani közösségben megtalálni.
\n\n
Még az is, hogy Monero folyamatosan hard forkol a múltban és a jelenben is, a projekt alázatát és erejét mutatja. Míg egyesek a hard forkokat fejlesztői központosításnak tartják –ami bizonyos mértékig igaz – ez azt is jelzi, hogy a fejlesztők belátták, csekély az esélye annak, hogy mindent elsőre 100%-osan jól csináljanak. A dolgokat javítani kell, sőt, akár teljesen lecserélni is szükséges lehet, ha a Monero versenyképes akar maradni mind az adatvédelmi, mind a kriptovaluta-térben.
\n\n
Gyakran előfordul, hogy ezek a változtatások megszüntetik a visszafelé kompatibilitást, ami komoly tabu a Bitcoin protokollban, ahol minden változásnak soft forknak és visszafelé kompatibilisnek kell lennie. Ez azonban azt jelenti, hogy a Bitcoin által végrehajtott egyes változtatások hatóköre nagyon korlátozott. Visszafogja őket a múltjuk, amit a fejlesztéseknek tiszteletben kell tartaniuk, gyakran értelmetlenül. Eközben a Monero változtatásai elsöprőek lehetnek, és gyakran nagyságrenddekkel javítják a protokollt és az adatbiztonságot.
\n\n
Ez könnyen látható a RingCT bevezetésén. Korábban a Monero csak arejtőzködő címeket és a gyűrűs aláírásokat tartalmazta, az összegek láthatók maradtak. Shen Noether, egy Monero-kutató módosított e


using System;
using System.Linq;
using Xunit;

namespace Semver.Test;

/// <summary>
/// Tests for the <see cref="SemVersion.With"/> and <see cref="SemVersion.WithParsedFrom"/>
/// methods. Each field change is tested independently to avoid combinatorial explosion.
/// </summary>
public class SemVersionWithTests
{
    public static readonly SemVersion Version = SemVersion.ParsedFrom(1, 2, 3, "pre", "metadata");

    #region With(...)
    [Fact]
    public void WithMajor()
    {
        var v = Version.With(major: 42);

        Assert.Equal(SemVersion.ParsedFrom(42, 2, 3, "pre", "metadata"), v);
    }

    [Theory]
    [InlineData(-1)]
    [InlineData(int.MinValue)]
    public void WithMajorInvalid(int majorVersion)
    {
        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => Version.With(major: majorVersion));
        Assert.StartsWith("Major version must be greater than or equal to zero.", ex.Message);
        Assert.Equal("major", ex.ParamName);
    }

    [Fact]
    public void WithMinor()
    {
        var v = Version.With(minor: 42);

        Assert.Equal(SemVersion.ParsedFrom(1, 42, 3, "pre", "metadata"), v);
    }

    [Theory]
    [InlineData(-1)]
    [InlineData(int.MinValue)]
    public void WithMinorInvalid(int minorVersion)
    {
        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => Version.With(minor: minorVersion));
        Assert.StartsWith("Minor version must be greater than or equal to zero.", ex.Message);
        Assert.Equal("minor", ex.ParamName);
    }

    [Fact]
    public void WithPatch()
    {
        var v = Version.With(patch: 42);

        Assert.Equal(SemVersion.ParsedFrom(1, 2, 42, "pre", "metadata"), v);
    }

    [Theory]
    [InlineData(-1)]
    [InlineData(int.MinValue)]
    public void WithPatchInvalid(int patchVersion)
    {
        var ex = Assert.Throws<ArgumentOutOfRangeException>(() => Version.With(patch: patchVersion));
        Assert.StartsWith("Patch version must be greater than or equal to zero.", ex.Message);
        Assert.Equal("patch", ex.ParamName);
    }

    [Fact]
    public void WithPrerelease()
    {
        var v = Version.With(prerelease: new[]
        {
            new PrereleaseIdentifier("bar"),
            new PrereleaseIdentifier("baz"),
            new PrereleaseIdentifier(100),
            new PrereleaseIdentifier("123abc"),
        });

        Assert.Equal(SemVersion.ParsedFrom(1, 2, 3, "bar.baz.100.123abc", "metadata"), v);
    }

    [Fact]
    public void WithPrereleaseEmpty()
    {
        var v = Version.With(prerelease: Enumerable.Empty<PrereleaseIdentifier>());

        Assert.Equal(SemVersion.ParsedFrom(1, 2, 3, "", "metadata"), v);
    }

    [Fact]
    public void WithPrereleaseDefaultIdentifier()
    {
        var ex = Assert.Throws<ArgumentException>(()
            => Version.With(prerelease: new PrereleaseIdentifier[] { default }));
        Assert.StartsWith("Prerelease identifier cannot be default/null.", ex.Message);
        Assert.Equal("prerelease", ex.ParamName);
    }

    [Fact]
    public void WithMetadata()
    {
        var v = Version.With(metadata: new[]
        {
            new MetadataIdentifier("bar"),
            new MetadataIdentifier("baz"),
            new MetadataIdentifier("100"),
            new MetadataIdentifier("123abc"),
        });

        Assert.Equal(SemVersion.ParsedFrom(1, 2, 3, "pre", "bar.baz.100


) * e(proof, generator_of_g2)
        // which is to check
        //  e(com^hash_inverse,  param[n-index-1]) * e(proof^{-hash_inverse}, generator_of_g2)
        //  ?= gt_elt
        // We modify the formula as above in order to avoid slow exponentation in the target group (which is Fq12)
        // and perform two scalar multiplication by to 1/hash(value) in G1 instead, which is considerably faster.
        // We also move the pairing from the right-hand-side to the left-hand-side in order
        // to take advantage of the pairing product computation, which is faster than two pairings.

        // step 1. compute hash_inverse
        let hash = hash_to_field_pointproofs(&value);
        // we can safely assume that hash is invertible
        // see `hash_to_field` function
        let hash_inverse = hash.inverse().unwrap();

        // step 2, compute com^hash_inverse and proof^{-hash_inverse}
        let mut com_mut = com.commit;
        let mut proof_mut = self.proof;
        proof_mut.negate();
        com_mut.mul_assign(hash_inverse);
        proof_mut.mul_assign(hash_inverse);

        // step 3. check pairing product
        pointproofs_pairing_product(
            com_mut.into_affine(),
            verifier_params.generators[verifier_params.n - index - 1],
            proof_mut.into_affine(),
            PointproofsG2Affine::one(),
        ) == verifier_params.gt_elt
    }

    /// Aggregates a vector of proofs from a same commitment into a single one.
    ///     * input: the commitment
    ///     * input: the list of proofs
    ///     * input: the list of the indices of the proofs
    ///     * input: the list of the values of the proofs
    ///     * input: parameter n (size of the vector)
    ///     * output: the aggregated proof
    ///     * error: invalid ciphersuite/length, or hash to scalars failes
    ///     * Note:
    ///         the aggregator does not check the validity of individual commit/proofs.
    ///         The caller may need to check them if they care for it.
    pub fn same_commit_aggregate<Blob: AsRef<[u8]>>(
        commit: &Commitment,
        proofs: &[Self],
        set: &[usize],
        value_sub_vector: &[Blob],
        n: usize,
    ) -> Result<Self, String> {
        // check that the csids are valid/match
        let csid = commit.ciphersuite;
        if !check_ciphersuite(csid) {
            return Err(ERR_CIPHERSUITE.to_owned());
        }
        for e in proofs.iter() {
            if e.ciphersuite != csid {
                return Err(ERR_CIPHERSUITE.to_owned());
            }
        }
        // check that the length of proofs and sets match
        if proofs.len() != set.len() || proofs.len() != value_sub_vector.len() {
            return Err(ERR_INDEX_PROOF_NOT_MATCH.to_owned());
        }

        if !misc::has_unique_elements(set) {
            return Err(ERR_DUPLICATED_INDEX.to_owned());
        }

        // get the list of scalas
        let ti = hash_to_ti_repr(commit, set, value_sub_vector, n)?;
        let scalars_u64: Vec<&[u64; 4]> = ti.iter().map(|s| &s.0).collect();

        let mut bases: Vec<PointproofsG1> = proofs.iter().map(|s| s.proof).collect();
        CurveProjective::batch_normalization(&mut bases);
        let bases_affine: Vec<PointproofsG1Affine> =
            bases.iter().map(|s| s.into_affine()).c


start_6, %g1, %r20
	ta	T_CHANGE_HPRIV
	mov	0x38, %g1
	stxa	%r20, [%g1] 0x58
	ta	T_CHANGE_NONHPRIV
	.word 0xfa2d8000  ! 362: STB_R	stb	%r29, [%r22 + %r0]
	setx	data_start_4, %g1, %r18
	ta	T_CHANGE_HPRIV
	mov	0x38, %g1
	stxa	%r18, [%g1] 0x58
	ta	T_CHANGE_NONHPRIV
	ta	T_CHANGE_HPRIV
	.word 0x81982b8b  ! 366: WRHPR_HPSTATE_I	wrhpr	%r0, 0x0b8b, %hpstate
	.word 0xf73ce162  ! 367: STDF_I	std	%f27, [0x0162, %r19]
	.word 0x8395a0fa  ! 368: WRPR_TNPC_I	wrpr	%r22, 0x00fa, %tnpc
	.word 0xb5518000  ! 369: RDPR_PSTATE	rdpr	%pstate, %r26
	.word 0xb151c000  ! 371: RDPR_TL	<illegal instruction>
	.word 0xfe246077  ! 372: STW_I	stw	%r31, [%r17 + 0x0077]
	.word 0xbf504000  ! 373: RDPR_TNPC	<illegal instruction>
hwintr_3_22:
!$EV trig_pc_d(3,expr(@VA(.MAIN.hwintr_3_22), 16, 16)) -> intp(3, 0, 2a)
	.word 0xb9480000  ! 377: RDHPR_HPSTATE	rdhpr	%hpstate, %r28
	.word 0xfe3dc000  ! 379: STD_R	std	%r31, [%r23 + %r0]
	.word 0x9195a08b  ! 381: WRPR_PIL_I	wrpr	%r22, 0x008b, %pil
	.word 0x8994e153  ! 385: WRPR_TICK_I	wrpr	%r19, 0x0153, %tick
	.word 0xfc350000  ! 387: STH_R	sth	%r30, [%r20 + %r0]
	.word 0x9195a1dd  ! 388: WRPR_PIL_I	wrpr	%r22, 0x01dd, %pil
	.word 0xb7480000  ! 389: RDHPR_HPSTATE	rdhpr	%hpstate, %r27
	ta	T_CHANGE_HPRIV
	.word 0x81982e43  ! 392: WRHPR_HPSTATE_I	wrhpr	%r0, 0x0e43, %hpstate
hwintr_3_23:
!$EV trig_pc_d(3,expr(@VA(.MAIN.hwintr_3_23), 16, 16)) -> intp(3, 0, a)
	.word 0xf234a061  ! 396: STH_I	sth	%r25, [%r18 + 0x0061]
	.word 0xf634c000  ! 398: STH_R	sth	%r27, [%r19 + %r0]
	.word 0xbd2d2001  ! 399: SLL_I	sll 	%r20, 0x0001, %r30
	.word 0xfc250000  ! 400: STW_R	stw	%r30, [%r20 + %r0]
	.word 0xbb2ca001  ! 403: SLL_I	sll 	%r18, 0x0001, %r29
hwintr_3_24:
!$EV trig_pc_d(3,expr(@VA(.MAIN.hwintr_3_24),


 clipsNotifierProvider;
  static const $allTransitiveDependencies1 =
      ClipsNotifierProvider.$allTransitiveDependencies0;
  static const $allTransitiveDependencies2 =
      ClipsNotifierProvider.$allTransitiveDependencies1;
  static const $allTransitiveDependencies3 = _notesClipsNotifierProvider;

  @override
  String debugGetCreateSourceHash() => _$_clipModalSheetNotifierHash();

  @override
  String toString() {
    return r'_clipModalSheetNotifierProvider'
        ''
        '($argument)';
  }

  @$internal
  @override
  _ClipModalSheetNotifier create() => _ClipModalSheetNotifier();

  @override
  bool operator ==(Object other) {
    return other is _ClipModalSheetNotifierProvider &&
        other.argument == argument;
  }

  @override
  int get hashCode {
    return argument.hashCode;
  }
}

String _$_clipModalSheetNotifierHash() =>
    r'fddcebc6d9fea1cad80273a56814897940856d5c';

final class _ClipModalSheetNotifierFamily extends $Family
    with
        $ClassFamilyOverride<
          _ClipModalSheetNotifier,
          AsyncValue<List<(Clip, bool)>>,
          List<(Clip, bool)>,
          FutureOr<List<(Clip, bool)>>,
          String
        > {
  const _ClipModalSheetNotifierFamily._()
    : super(
        retry: null,
        name: r'_clipModalSheetNotifierProvider',
        dependencies: const <ProviderOrFamily>[
          clipsNotifierProvider,
          _notesClipsNotifierProvider,
          misskeyPostContextProvider,
        ],
        $allTransitiveDependencies: const <ProviderOrFamily>{
          _ClipModalSheetNotifierProvider.$allTransitiveDependencies0,
          _ClipModalSheetNotifierProvider.$allTransitiveDependencies1,
          _ClipModalSheetNotifierProvider.$allTransitiveDependencies2,
          _ClipModalSheetNotifierProvider.$allTransitiveDependencies3,
        },
        isAutoDispose: true,
      );

  _ClipModalSheetNotifierProvider call(String noteId) =>
      _ClipModalSheetNotifierProvider._(argument: noteId, from: this);

  @override
  String toString() => r'_clipModalSheetNotifierProvider';
}

abstract class _$ClipModalSheetNotifier
    extends $AsyncNotifier<List<(Clip, bool)>> {
  late final _$args = ref.$arg as String;
  String get noteId => _$args;

  FutureOr<List<(Clip, bool)>> build(String noteId);
  @$mustCallSuper
  @override
  void runBuild() {
    final created = build(_$args);
    final ref =
        this.ref as $Ref<AsyncValue<List<(Clip, bool)>>, List<(Clip, bool)>>;
    final element =
        ref.element
            as $ClassProviderElement<
              AnyNotifier<AsyncValue<List<(Clip, bool)>>, List<(Clip, bool)>>,
              AsyncValue<List<(Clip, bool)>>,
              Object?,
              Object?
            >;
    element.handleValue(ref, created);
  }
}

// ignore_for_file: type=lint
// ignore_for_file: subtype_of_sealed_class, invalid_use_of_internal_member, invalid_use_of_visible_for_testing_member, deprecated_member_use_from_same_package
// GENERATED CODE - DO NOT MODIFY BY HAND
// coverage:ignore-file
// ignore_for_file: type=lint
// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark

part of 'share_extension_page.dart';

// *****************************************************


//
// Copyright 2023 Google LLC
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.
//

using Google.Solutions.Mvvm.Theme;
using NUnit.Framework;
using System.Threading;
using System.Windows.Forms;

namespace Google.Solutions.Mvvm.Test.Theme
{
    [TestFixture]
    [Apartment(ApartmentState.STA)]
    public class TestCommonControlTheme
    {
        [Test]
        public void Columns_WhenListWiderThanColumns_ThenLastColumnIsEnlarged()
        {
            using (var form = new Form()
            {
                Width = 400,
                Height = 400
            })
            {
                var listView = new ListView()
                {
                    Dock = DockStyle.Fill,
                    View = View.Details
                };
                var column1 = new ColumnHeader()
                {
                    Text = "Col-1",
                    Width = 100
                };
                var column2 = new ColumnHeader()
                {
                    Text = "Col-2",
                    Width = 100
                };

                listView.Columns.Add(column1);
                listView.Columns.Add(column2);

                form.Controls.Add(listView);

                new CommonControlRuleSet().AutoSizeListViewColumns(listView);
                form.Show();

                Assert.AreEqual(100, column1.Width);
                Assert.AreNotEqual(100, column2.Width);

                form.Close();
            }
        }

        [Test]
        public void Col


管人员和其他直接责任人员，依法给予处分；构成犯罪的，依法追究刑事责任；给当事人造成损失的，依法承担赔偿责任：

（一）对应当受理的事项不予受理，或者应当予以制止和处罚的违法行为不予制止、处罚，致使公民、法人或者其他组织的合法权益、公共利益和社会秩序遭受损害的；

（二）违反规定收取费用或者实施行政处罚的；

（三）殴打、辱骂、刁难当事人的；

（四）故意损坏、擅自处置或者侵占当事人财物的；

（五）其他玩忽职守、滥用职权、徇私舞弊的行为。

第六十二条 市、县（市、区）人民政府应当建立公安、生态环境、城市管理、卫生健康、行政审批服务、市场监管等部门的城镇容貌和环境卫生联合执法制度与执法保障机制。

违反本条例规定，阻碍城市管理部门和其他有关部门工作人员依法执行公务，或者侮辱、殴打相关工作人员的，由公安机关依法予以处罚；构成犯罪的，依法追究刑事责任。

第六十三条 严格执行罚缴分离、收支两条线制度，不得将城市管理经费与罚没收入挂钩。市、县（市、区）人民政府应当保障城市管理人员、装备、技术等方面的资金投入。

第六十四条 城市管理部门在执法过程中，依法可以采取以下措施：

（一）进入现场进行检查、勘查（验），要求相关单位和个人说明情况，提供有关资料；

（二）查阅、调阅、复制、拍摄有关证据材料；

（三）法律、法规、规章规定的其他措施。

第六十五条 城市管理部门应当会同其他有关部门、审判机关、检察机关、公安机关，建立并落实城镇容貌和环境卫生管理执法联席会议、信息共享、案情通报、案件移送等制度。

## 第六章  附则

第六十六条 城市家具，是指城市中为公众生活、出行等提供公共服务的指路标志、垃圾容器、站点、座椅等配套设施，一般设置在街道、广场、绿地或者其他公共部位，是城


this.r.set(1.0);
        }
     }

    /** Get search direction.
     * @return search direction
     */
    RealVector getDx() {
       return  this.dx;
    }

}
/*
 * Licensed to the Hipparchus project under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The Hipparchus project licenses this file to You 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.
 */

package org.hipparchus.optim.nonlinear.vector.constrained;

import org.hipparchus.linear.Array2DRowRealMatrix;
import org.hipparchus.linear.ArrayRealVector;
import org.hipparchus.linear.MatrixUtils;
import org.hipparchus.linear.RealMatrix;
import org.hipparchus.linear.RealVector;
import org.hipparchus.optim.nonlinear.scalar.ObjectiveFunction;
import org.hipparchus.util.FastMath;
import org.hipparchus.util.Precision;

/**
 * Sequential Quadratic Programming Optimizer (extended version).
 *
 *

 * Minimizes a nonlinear objective function subject to equality, inequality, and
 * box constraints using a Sequential Quadratic Programming method. This
 * implementation is inspired by the algorithm described in: "On the convergence
 * of a sequential quadratic programming method" by Klaus Schittkowski (1982).
 *

 *
 *

 * Supports: equality constraints, inequality constraints,
 * penalty function updates, line search strategies, BFGS Hessian update, and
 * augmented QP formulation using a relaxation variable.

 *
 * @since 3.1
 */
public class SQPOptimizerS2 extends AbstractSQPOptimizer2 {

    /** Logger. */
    private final SQPLogger formatter = SQPLogger.defaultLogger();

    /**
     * Value of the equality constraints.
     */
    private RealVector eqEval;

    /**
     * Value of the inequality constraints.
     */
    private RealVector ineqEval;

    /**
     * Gradient of the objective function.
     */
    private RealVector J;

    /**
     * Hessian approximation.
     */
    private RealMatrix H;

    /**
     * Jacobian of the inequality constraints.
     */
    private RealMatrix JI;

    /**
     * Jacobian of the equality constraints.
     */
    private RealMatrix JE;

    /** Evaluation of the objective function. */
    private double functionEval;

    /** Current point. */
    private RealVector x;

    /**
     * {@inheritDoc}
     */
    @Override
    public LagrangeSolution doOptimize() {
        formatter.setEps(getSettings().getEps());
        formatter.logHeader();
        int me = 0;
        int mi = 0;

        //EQUALITY CONSTRAINT
        if (this.getEqConstraint() != null) {
            me = getEqConstraint().dimY();
        }
        //INEQUALITY CONSTRAINT
        if (this.getIqConstraint() != null) {
            mi = getIqConstraint().dimY();
        }
        final int m = me + mi;

        double alpha;
        double rho = getSettings().getRhoCons(); //get initial value of slack variable from SQPOption

        if (this.getStartPoint() != null) {
            x = new ArrayRealVector(this.getStartPoint());
        } else {
            x = new


<=";break;default:throw new TypeError('Must provide a hilo val of "<" or ">"')}if(m(n,a,o))return!1;for(let e=0;e<a.set.length;++e){const p=a.set[e];let t=null,r=null;if(p.forEach(e=>{e.semver===h&&(e=new d(">=0.0.0")),t=t||e,r=r||e,s(e.semver,t.semver,o)?t=e:l(e.semver,r.semver,o)&&(r=e)}),t.operator===c||t.operator===u)return!1;if((!r.operator||r.operator===c)&&i(n,r.semver))return!1;if(r.operator===u&&l(n,r.semver))return!1}return!0}}}),Ae=e({"node_modules/semver/ranges/gtr.js"(e,t){var n=Pe();t.exports=(e,t,r)=>n(e,t,">",r)}}),Te=e({"node_modules/semver/ranges/ltr.js"(e,t){var n=Pe();t.exports=(e,t,r)=>n(e,t,"<",r)}}),Me=e({"node_modules/semver/ranges/intersects.js"(e,t){var n=V();t.exports=(e,t,r)=>(e=new n(e,r),t=new n(t,r),e.intersects(t))}}),De=e({"node_modules/semver/ranges/simplify.js"(e,t){var h=je(),f=q();t.exports=(e,t,r)=>{const n=[];let a=null,o=null;var s,i,l=e.sort((e,t)=>f(e,t,r));for(const d of l){var c=h(d,t,r);a=c?(o=d,a||d):(o&&n.push([a,o]),o=null)}a&&n.push([a,null]);const u=[];for([s,i]of n)s===i?u.push(s):i||s!==l[0]?i?s===l[0]?u.push("<="+i):u.push(s+" - "+i):u.push(">="+s):u.push("*");var e=u.join(" || "),p="string"==typeof t.raw?t.raw:String(t);return e.length<p.length?e:t}}}),$e=e({"node_modules/semver/ranges/subset.js"(e,t){var i=V(),v=Oe(),b=v["ANY"],y=je(),w=q(),E=(e,t,r)=>{return!e||!(0<(r=w(e.semver,t.semver,r)))&&(r<0||">"===t.operator&&">="===e.operator)?t:e},S=(e,t,r)=>{return!e||!((r=w(e.semver,t.semver,r))<0)&&(0<r||"<"===t.operator&&"<="===e.operator)?t:e};t.exports=(t,r,n={})=>{if(t!==r){t=new i(t,n),r=new i(r,n);let e=!1;e:for(const o of t.set){for(const s of r.set){var a=((i,l,c)=>{if(i!==l){if(1===i.length&&i[0].semver===b){if(1===l.length&&l[0].semver===b)return!0;i=c.includePrerelease?[new v(">=0.0.0-0")]:[new v(">=0.0.0")]}if(1===l.length&&l[0].semver===b){if(c.includePrerelease)return!0;l=[new v(">=0.0.0")]}const d=new Set;let e,t;for(const h of i)">"===h.oper


1f',GradientType=0 ); /* IE6-9 */
}

.fullrounded img {
   -webkit-border-radius: 400px;
-moz-border-radius: 400px;
border-radius: 400px;
  }
/* LayerSlider Borderless Dark 3D Skin */

.ls-borderlessdark3d .ls-ct-half {
	background: #444;
}

.ls-borderlessdark3d .ls-ct-center {
	background: white;
}

.ls-borderlessdark3d .ls-playvideo {
	width: 50px;
	height: 50px;
	margin-left: -25px;
	margin-top: -25px;
}

.ls-borderlessdark3d .ls-playvideo,
.ls-borderlessdark3d .ls-nav-sides,
.ls-borderlessdark3d .ls-bottom-slidebuttons a,
.ls-borderlessdark3d .ls-nav-prev,
.ls-borderlessdark3d .ls-nav-next,
.ls-borderlessdark3d .ls-nav-start,
.ls-borderlessdark3d .ls-nav-stop,
.ls-borderlessdark3d .ls-fullscreen,
.ls-borderlessdark3d .ls-loading-container {
	background-image: url(skin.png);
}

.ls-borderlessdark3d .ls-playvideo {
	background-position: -300px -150px;
}

.ls-borderlessdark3d .ls-playvideo:hover,
.ls-borderlessdark3d .ls-vpcontainer:hover .ls-playvideo {
	background-position: -375px -150px;
}

.ls-borderlessdark3d .ls-nav-prev {
	background-position: 0px 0px;
}

.ls-borderlessdark3d .ls-nav-prev:hover {
	background-position: 0px -75px;
}

.ls-borderlessdark3d .ls-nav-next {
	background-position: -150px 0px;
}

.ls-borderlessdark3d .ls-nav-next:hover {
	background-position: -150px -75px;
}

.ls-borderlessdark3d .ls-nav-start {
	background-position: -300px 0px;
}

.ls-borderlessdark3d .ls-nav-start:hover,
.ls-borderlessdark3d .ls-nav-start-active {
	background-position: -300px -75px;
}

.ls-borderlessdark3d .ls-nav-stop {
	background-position: -450px 0px;
}

.ls-borderlessdark3d .ls-nav-stop:hover,
.ls-borderlessdark3d .ls-nav-stop-active {
	background-position: -450px -75px;
}

.ls-borderlessdark3d .ls-bottom-slidebuttons a {
	background-position: 0px -150px;
}

.ls-borderlessdark3d .ls-bottom-slidebuttons a.ls-nav-active,
.ls-borderlessdark3d .ls-bottom-slidebuttons a:hover {
	background-position: -75px -150px;
}

.ls-borderlessdark3d .ls-nav-sideleft {
	background-position: -150px -150px;
}

.ls-borderlessdark3d .ls-nav-sideright {
	background-position: -225px -150px;
}

.ls-borderlessdark3d .ls-nav-prev,
.ls-borderlessdark3d .ls-nav-next {
	width: 40px;
	height: 40px;
	z-index: 10000;
	top: 50%;
	margin-top: -20px;
	position: absolute;
}

.ls-borderlessdark3d .ls-nav-prev {
	lef


nTest {
        val processor = getProcessor()

        val packageName = "com.forpda.lp".toPkgId()
        mockPkg(packageName)

        val prefixFree = "something-123.odex"

        for (base in bases) {
            val toHit = base.child(prefixFree)
            val locationInfo = processor.identifyArea(toHit)!!.apply {
                prefix shouldBe base
                prefixFreeSegments shouldBe listOf(prefixFree)
            }

            processor.findOwners(locationInfo).apply {
                owners.single().apply {
                    pkgId shouldBe packageName
                    flags shouldBe setOf(Marker.Flag.CUSTODIAN)
                }
            }
        }
    }

    @Test fun testProcess_nothing() = runTest {
        val processor = getProcessor()

        for (base in bases) {
            val suffix = rngString
            val toHit = base.child(suffix)
            val locationInfo = processor.identifyArea(toHit)!!.apply {
                prefix shouldBe base
                prefixFreeSegments shouldBe listOf(suffix)
            }

            processor.findOwners(locationInfo).apply {
                owners.size shouldBe 0
                hasKnownUnknownOwner shouldBe false
            }
        }
    }

    @Test fun testProcess_android11_double_hash_standard_packages() = runTest {
        val processor = getProcessor()

        val testCases = listOf(
            "com.example.deeplviewer" to "~~4IQxTCyRFPq4S53KU3KhBQ==/com.example.deeplviewer-ekB8USahHaRHG-eHQqgtaA==/",
            "com.unciv.app" to "~~4SQmc6pIMWUKe4duEnDYLA==/com.unciv.app-tedbtxdTjOq9-Zi5XmVZ9A==/",
            "com.mixplorer.addon.tagger" to "~~D8kt0_yGoTzeRfPqpXig_A==/com.mixplorer.addon.tagger-7Mv8xwIcEfyZQxHsN3crBg==/",
            "com.android.chrome" to "~~KV8oafUkVvQFcQ0CrB9Xcg==/com.android.chrome-u8-iRxh1dNuDLvYFLhiLCg==/"
        )

        for ((packageName, pathPattern) in testCases) {
            val pkgId = packageName.toPkgId()
            mockPkg(pkgId)

            for (base in bases) {
                val toHit = base.child(pathPattern.toSegs())
                val locationInfo = processor.identifyArea(toHit)!!
                processor.findOwners(locationInfo).apply {
                    owners.single().pkgId shouldBe pkgId
                }
            }
        }
    }

    @Test fun testProcess_android11_versioned_trichrome_packages() = runTest {
        val processor = getProcessor()

        val testCases = listOf(
            "com.google.android.trichromelibrary_661308832" to "~~LZPmWFF7U8b5p2t4TdZl_g==/com.google.android.trichromelibrary_661308832-Kg7UPJMq-h9KEhvNLQ_MQQ==/",
            "com.google.android.trichromelibrary_725805143" to "~~Wk3_8lFYVcexJSSp02wnBA==/com.google.android.trichromelibrary_725805143-cdAJ89ohmzvBP2SPp0jbFw==/",
            "com.google.android.trichromelibrary_720416833" to "~~hRTU7eqvvwqGI1M_HDkSYw==/com.google.android.trichromelibrary_720416833-SwGRwNc5AwLq6Ex3nV4SRw==/"
        )

        for ((packageName, pathPattern) in testCases) {
            val pkgId = packageName.toPkgId()
            mockPkg(pkgId)

            for (base in bases) {
                val toHit = base.child(pathPattern)
                val locationInfo = processor.identifyArea(toHit)!!
                processor.findOwners(


me = timestamp("start_time")
    val endTime = timestamp("end_time")
}

class EvaluatorRunDao(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<EvaluatorRunDao>(EvaluatorRunsTable)

    var evaluatorJobId by EvaluatorRunsTable.evaluatorJobId.transformToEntityId()
    var evaluatorJob by EvaluatorJobDao referencedOn EvaluatorRunsTable.evaluatorJobId
    var startTime by EvaluatorRunsTable.startTime.transformToDatabasePrecision()
    var endTime by EvaluatorRunsTable.endTime.transformToDatabasePrecision()
    var violations by RuleViolationDao via EvaluatorRunsRuleViolationsTable

    fun mapToModel() = EvaluatorRun(
        id = id.value,
        evaluatorJobId = evaluatorJob.id.value,
        startTime = startTime,
        endTime = endTime,
        violations = violations.map { it.mapToModel() }
    )
}
/*
 * Copyright (C) 2023 The ORT Server Authors (See <https://github.com/eclipse-apoapsis/ort-server/blob/main/NOTICE>)
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

package org.eclipse.apoapsis.ortserver.dao.repositories.ortrun

import org.jetbrains.exposed.dao.LongEntity
import org.jetbrains.exposed.dao.LongEntityClass
import org.jetbrains.exposed.dao.id.EntityID
import org.jetbrains.exposed.dao.id.LongIdTable
import org.jetbrains.exposed.sql.and

/**
 * A table to represent an ORT run.
 */
object LabelsTable : LongIdTable("labels") {
    val key = text("key")
    val value = text("value")
}

class LabelDao(id: EntityID<Long>) : LongEntity(id) {
    companion object : LongEntityClass<LabelDao>(LabelsTable) {
        private fun findByKeyAndValue(key: String, value: String): LabelDao? =
            find { LabelsTable.key eq key and (LabelsTable.value eq value) }.firstOrNull()

        fun getOrPut(key: String, value: String): LabelDao =
            findByKeyAndValue(key, value) ?: new {
                this.key = key
                this.value = value
            }
    }

    var key by LabelsTable.key
    var value by LabelsTable.value

    fun mapToModel() = Pair(key, value)
}
/*
 * Copyright (C) 2023 The ORT Server Authors (See <https://github.com/eclipse-apoapsis/ort-server/blob/main/NOTICE>)
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

package org.eclipse.apoapsis


Something());

            expected.Push(new Something());

            Serialize(expected);
            Reset();
            var actual = Deserialize<Stack<Something>>();
            Assert.Equal(expected.ToList(), actual.ToList());
        }

        [Fact]
        public void Issue18()
        {
            var msg = new byte[] {1, 2, 3, 4};
            var serializer = new Serializer(new SerializerOptions(true));

            byte[]


strcmp(typeid(Derived).name(), "i") == 0) // the passed in matrix is Int
                m(i, 0) = value[i].asInt();
            else // the passed in matrix is should be double
                m(i, 0) = value[i].asDouble();
        }
    }
    else  { // a matrix
        m.resize(value.size(), value[0u].size());
        for (uint i = 0; i < value.size(); i++)
            for (uint j = 0; j < value[i].size(); j++)
            {
                if (strcmp(typeid(Derived).name(), "i") == 0)
                    m(i, j) = value[i][j].asInt();
                else
                    m(i, j) = value[i][j].asDouble();
            }
    }
    // std::cout << m << std::endl;
}

template<typename Derived, int option>
void initSparseMatrix(Eigen::SparseMatrix<Derived, option>& m, const Json::Value& value)
{
    if (strcmp(typeid(Derived).name(), "i") == 0)
    {
        // The first row specifies the size of the sparse matrix
        m.resize(value[0u][0u].asInt(), value[0u][1u].asInt());
        for (uint k = 1u; k < value.size(); k++)
        {
            assert(value[k].size() == 3);
            // From the second row on, triplet correspond to matrix entries
            const int i = value[k][0u].asInt();
            const int j = value[k][1u].asInt();
            m.insert(i, j) = value[k][2u].asInt();
        }
    }
    else
    {
        // The first row specifies the size of the sparse matrix
        m.resize(value[0u][0u].asInt(), value[0u][1u].asInt());
        for (uint k = 1u; k < value.size(); k++)
        {
            assert(value[k].size() == 3);
            // From the second row on, triplet correspond to matrix entries
            const int i = value[k][0u].asInt();
            const int j = value[k][1u].asInt();
            m.insert(i, j) = value[k][2u].asDouble();
        }
    }
    std::cout << "rows " << m.rows() << " cols " << m.cols() << std::endl;
}

void LoadHandModelFromJson( HandModel &handm, const std::string &path )
{
    printf("Loading from: %s\n", path.c_str());
    Json::Value root;
    std::ifstream file(path.c_str(), std::ifstream::in);
    file >> root;
    initMatrix(handm.update_inds_, root["update_inds"]);
    initMatrix(handm.parents_, root["parents"]);
    initMatrix(handm.m_jointmap_pm2model, root["joint_order"]);
    initMatrix(handm.pose_limits_, root["pose_limits"]);
    initMatrix(handm.coeffs_limits_, root["coeffs_limits"]);
    initMatrixRowMajor(handm.m_M_l2pl, root["MTa"]);
    initMatrixRowMajor(handm.m_M_w2l, root["MTi"]);
    // initMatrix(handm.pose_prior_A_, root["pose_prior_A"]);
    // initMatrix(handm.pose_prior_mu_, root["pose_prior_mu"]);
    initMatrix(handm.coeffs_prior_A_, root["coeffs_prior_A"]);
    initMatrix(handm.coeffs_prior_mu_, root["coeffs_prior_mu"]);
    initMatrixRowMajor(handm.V_, root["V"]);
    // initMatrixRowMajor(handm.m_T_hand2smpl, root["T_hand2smpl"]);
    int handRootJoint = handm.update_inds_(0);
    handm.m_M_rootlocal2smplW = handm


if (err) {
        return res.status(403).send({
          error: "Could not verify access token.",
        });
      }

      if (user) {
        const { token: dbToken } = await User.query()
          .select("token")
          .where({ id: (<IUser>user).id })
          .first();

        if (!dbToken) {
          debug("Token not found in database.");

          return res.status(401).send("Token Expired.");
        }

        if (dbToken && dbToken !== token) {
          debug("Access token with same user ID does not match with database token.");

          return res.status(500).send({
            error: "Faulty token.",
          });
        }

        if (new Date() > new Date((<IUser>user).expiresAt)) {
          debug("Token past two weeks expiration period.");

          return res.status(401).send("Token Expired.");
        }

        req.user = <IUser>user;
        next();
      } else {
        debug("No user data found in access token.");

        //TODO: add API spec.
        return res.status(500).send({
          error: "Faulty token.",
        });
      }
    });
  } else {
    res.status(401).send({
      error: "Please supply authentication token to access protected route.",
    });
  }
}
import { Component } from '@angular/core';

@Component({
    selector: 'pipes',
    template: `

Pipes:

data:{{ date | date: 'yyyy-MM-dd' }}

number: {{ 100.2968 | number: '1.2-2' }}

currency: {{ 100.2968 | currency: 'CNY':true }}

json: {{ jsonObj | json }}

slice: {{ 'hello world' | slice:2:6 }}

percent: {{ 1/3 | percent }}

async: {{ asyncPipe | async }}

custome: {{ 'ab|cd|efg' | customePipe }}

    `
})
export class Pipes {
    date: Date = new Date();
    jsonObj = {
        name: 'jay',
        todo: 'something'
    };

    asyncPipe = new Promise((resolve, relect) => {
        setTimeout(() => resolve("OK"), 1000);
    }).then();
}import { Container, Point } from 'pixi.js';
import { Dimension } from './commons';
import { Layout } from './constants';
import SoundManager from './SoundManager';
import { centerX, LayoutOptions, newAnimatedSprite, newSprite, postionOnBottom } from './utils';
import { Button } from './utils/Button';
import { FightStatus } from './BattleScreen';
import { Tween } from '@tweenjs/tween.js';

export type IconName = 'IcoTronium' | 'IcoShield' | 'IcoClose' | 'IcoHowtoPlay' | 'IcoArrow';

const PrimeryButtons = {
  connect: {
    image: 'BtnConnect.png',
    size: {
      width: 250,
      height: 100,
    },
  },
};

function icon(name: IconName, opts: Pick<LayoutOptions, 'anchor' | 'position'> = {}) {
  return newSprite(name + '.png', {
    ...opts,
  });
}

export function smallIcon(name: IconName, opts: Pick<LayoutOptions, 'anchor' | 'position'> = {}) {
  const i = icon(name, opts);
  i.width = 24;
  i.height = 24;
  return i;
}

export function bigIcon(name: IconName, opts: Pick<LayoutOptions, 'anchor' | 'position'> = {}) {
  return icon(name, opts);
}

export function primaryBtn(
  name: keyof typeof PrimeryButtons,
  action: () => void,
  parent: Container
) {
  const BottomMargin = 50;
  const spec = PrimeryButtons[name];
  const btnSprite = newSprite(spec.image, {
    anchor: new Point(0.


abbr[title]{cursor:help;border-bottom:1px dotted #777}.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:10px 20px;margin:0 0 20px;font-size:17.5px;border-left:5px solid #eee}blockquote ol:last-child,blockquote p:last-child,blockquote ul:last-child{margin-bottom:0}blockquote .small,blockquote footer,blockquote small{display:block;font-size:80%;line-height:1.42857143;color:#777}blockquote .small:before,blockquote footer:before,blockquote small:before{content:'\2014 \00A0'}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;text-align:right;border-right:5px solid #eee;border-left:0}.blockquote-reverse .small:before,.blockquote-reverse footer:before,.blockquote-reverse small:before,blockquote.pull-right .small:before,blockquote.pull-right footer:before,blockquote.pull-right small:before{content:''}.blockquote-reverse .small:after,.blockquote-reverse footer:after,.blockquote-reverse small:after,blockquote.pull-right .small:after,blockquote.pull-right footer:after,blockquote.pull-right small:after{content:'\00A0 \2014'}address{margin-bottom:20px;font-style:normal;line-height:1.42857143}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,"Courier New",monospace}code{padding:2px 4px;font-size:90%;color:#c7254e;background-color:#f9f2f4;border-radius:4px}kbd{padding:2px 4px;font-size:90%;color:#fff;background-color:#333;border-radius:3px;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.25);box-shadow:inset 0 -1px 0 rgba(0,0,0,.25)}kbd kbd{padding:0;font-size:100%;font-weight:700;-webkit-box-shadow:none;box-shadow:none}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:1.42857143;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.row{margin-right:-15px;margin-left:-15px}.col-lg-1,.col-lg


ned by
        Session.make_callable is being run.

  Returns:
    (str) A short description of the run() call, including information about
      the fetche(s) and feed(s).
  """
  if is_callable_runner:
    return "runner from make_callable()"

  description = "run #%d: " % run_call_count

  if isinstance(fetches, (ops.Tensor, ops.Operation, variables.Variable)):
    description += "1 fetch (%s); " % common.get_graph_element_name(fetches)
  else:
    # Could be (nested) list, tuple, dict or namedtuple.
    num_fetches = len(common.get_flattened_names(fetches))
    if num_fetches > 1:
      description += "%d fetches; " % num_fetches
    else:
      description += "%d fetch; " % num_fetches

  if not feed_dict:
    description += "0 feeds"
  else:
    if len(feed_dict) == 1:
      for key in feed_dict:
        description += "1 feed (%s)" % (
            key if isinstance(key, six.string_types) or not hasattr(key, "name")
            else key.name)
    else:
      description += "%d feeds" % len(feed_dict)

  return description

def get_error_intro(tf_error):
  """Generate formatted intro for TensorFlow run-time error.

  Args:
    tf_error: (errors.OpError) TensorFlow run-time error object.

  Returns:
    (RichTextLines) Formatted intro message about the run-time OpError, with
      sample commands for debugging.
  """

  if hasattr(tf_error, "op") and hasattr(tf_error.op, "name"):
    op_name = tf_error.op.name
  else:
    op_name = None

  intro_lines = [
      "--------------------------------------",
      RL("!!! An error occurred during the run !!!", "blink"),
      "",
  ]

  out = debugger_cli_common.rich_text_lines_from_rich_line_list(intro_lines)

  if op_name is not None:
    out.extend(debugger_cli_common.RichTextLines(
        ["You may use the following commands to debug:"]))
    out.extend(
        _recommend_command("ni -a -d -t %s" % op_name,
                           "Inspect information about the failing op.",
                           create_link=True))
    out.extend(
        _recommend_command("li -r %s" % op_name,
                           "List inputs to the failing op, recursively.",
                           create_link=True))

    out.extend(
        _recommend_command(
            "lt",
            "List all tensors dumped during the failing run() call.",
            create_link=True))
  else:
    out.extend(debugger_cli_common.RichTextLines([
        "WARNING: Cannot determine the name of the op that caused the error."]))

  more_lines = [
      "",
      "Op name:    %s" % op_name,
      "Error type: " + str(type(tf_error)),
      "",
      "Details:",
      str(tf_error),
      "",
      "--------------------------------------",
      "",
  ]

  out.extend(debugger_cli_common.RichTextLines(more_lines))

  return out


Probe(DebugProbeError::Timeout));
        }

        if (interface.read_word_32(0x4003_4fe0)? & 0xB) == 0 {
            log::info!("No Error reading Flash Word with Reset Vector");

            reset_vector = interface.read_word_32(0x0000_0004)?;
        }

        if reset_vector != 0xffff_ffff {
            log::info!("Breakpoint on user application reset vector");

            interface.write_word_32(0xE000_2008, reset_vector | 1)?;
            interface.write_word_32(0xE000_2000, 3)?;
        }

        if reset_vector == 0xffff_ffff {
            log::info!("Enable reset vector catch");

            let mut demcr = Demcr(interface.read_word_32(Demcr::ADDRESS)?);

            demcr.set_vc_corereset(true);

            interface.write_word_32(Demcr::ADDRESS, demcr.into())?;
        }

        let _ = interface.read_word_32(Dhcsr::ADDRESS)?;

        log::debug!("reset_catch_set -- done");

        Ok(())
    }

    fn reset_catch_clear(&self, interface: &mut crate::Memory) -> Result<(), crate::Error> {
        use crate::architecture::arm::core::armv7m::Demcr;

        interface.write_word_32(0xE000_2008, 0x0)?;
        interface.write_word_32(0xE000_2000, 0x2)?;

        let mut demcr = Demcr(interface.read_word_32(Demcr::ADDRESS)?);

        demcr.set_vc_corereset(false);

        interface.write_word_32(Demcr::ADDRESS, demcr.into())
    }

    fn reset_system(&self, interface: &mut crate::Memory) -> Result<(), crate::Error> {
        use crate::architecture::arm::core::armv7m::Aircr;

        let mut aircr = Aircr(0);
        aircr.vectkey();
        aircr.set_sysresetreq(true);

        let mut result = interface.write_word_32(Aircr::ADDRESS, aircr.into());

        if result.is_ok() {
            result = interface.flush();
        }

        if let Err(e) = result {
            log::debug!("Error requesting reset: {:?}", e);
        }

        log::info!("Waiting after reset");
        thread::sleep(Duration::from_millis(10));

        wait_for_stop_after_reset(interface)
    }
}

fn wait_for_stop_after_reset(memory: &mut crate::Memory) -> Result<(), crate::Error> {
    use crate::architecture::arm::core::armv7m::Dhcsr;
    log::info!("Wait for stop after reset");

    thread::sleep(Duration::from_millis(10));

    let dp = memory.get_ap().dp;
    let interface = memory.get_arm_interface()?;

    enable_debug_mailbox(interface, dp)?;

    let mut timeout = true;

    let start = Instant::now();

    log::info!("Polling for reset");

    while start.elapsed() < Duration::from_micros(50_0000) {
        let dhcsr = Dhcsr(memory.read_word_32(Dhcsr::ADDRESS)?);

        if !dhcsr.s_reset_st() {
            timeout = false;
            break;
        }
    }

    if timeout {
        return Err(crate::Error::Probe(DebugProbeError::Timeout));
    }

    let dhcsr = Dhcsr(memory.read_word_32(Dhcsr::ADDRESS)?);

    if !dhcsr.s_halt() {
        let mut dhcsr = Dhcsr(0);
        dhcsr.enable_write();


=> {
			expect(fs.existsSync(sandbox.dir)).toEqual(true);

			const methods = getAllMethods(sandbox);
			methods.forEach((method) => {
				// @ts-ignore
				const item = sandbox[method];
				if (typeof item === 'function') {
					expect(item.name).toEqual(`bound ${method}`);
				}
			});
		};

		test('async', async () => {
			await sandbox.destroySandbox();
			sandbox = new TempSandbox();
			checkResult();
		});

		test('sync', () => {
			sandbox.destroySandboxSync();
			sandbox = new TempSandbox();
			checkResult();
		});
	});
});
import { Kind, URIS, Kind2, URIS2, HKT2 } from '@morphic-ts/common/lib/HKT'

/**
 *  @since 0.0.1
 */
export const StrMapURI = Symbol()
/**
 *  @since 0.0.1
 */
export type StrMapURI = typeof StrMapURI

declare module '@morphic-ts/algebras/lib/hkt' {
  interface Algebra<F> {
    [StrMapURI]: ModelAlgebraStrMap<F>
  }
  interface Algebra1<F extends URIS> {
    [StrMapURI]: ModelAlgebraStrMap1<F>
  }
  interface Algebra2<F extends URIS2> {
    [StrMapURI]: ModelAlgebraStrMap2<F>
  }
}

/**
 *  @since 0.0.1
 */
export interface ModelAlgebraStrMap<F> {
  _F: F
  strMap: <L, A>(codomain: HKT2<F, L, A>) => HKT2<F, Array<[string, L]>, Record<string, A>>
}

/**
 *  @since 0.0.1
 */
export interface ModelAlgebraStrMap1<F extends URIS> {
  _F: F
  strMap: <A>(codomain: Kind<F, A>) => Kind<F, Record<string, A>>
}

/**
 *  @since 0.0.1
 */
export interface ModelAlgebraStrMap2<F extends URIS2> {
  _F: F
  strMap: <L, A>(codomain: Kind2<F, L, A>) => Kind2<F, Record<string, L>, Record<string, A>>
}
import { IsGrantOfAsylumExpiredValidator } from '../../../src/validators/isPaperExpiredValidators/IsGrantOfAsylumExpiredValidator';
import { Papers } from '../../../src/Papers';
import { GrantOfAsylum } from '../../../src/papers/GrantOfAsylum';

describe('IsGrantOfAsylumExpiredValidator', () => {
    it('no grant of asylum, not expired', function () {
        const papers = new Papers();
        const validator = new IsGrantOfAsylumExpiredValidator();
        expect(validator.validate(papers)).toBeFalsy();
    });
    it('has grant of asylum, is expired', function () {
        const papers = new Papers();
        const grantOfAsylum = new GrantOfAsylum();
        grantOfAsylum.setExpirationDate(new Date('November 20, 1982'));
        papers.setGrantOfAsylum(grantOfAsylum);

        const validator = new IsGrantOfAsylumExpiredValidator();
        expect(validator.validate(papers)).toBeTruthy();
    });
    it('has grant of asylum, not expired', function () {
        const papers = new Papers();
        const grantOfAsylum = new GrantOfAsylum();
        grantOfAsylum.setExpirationDate(new Date('November 25, 1982'));
        papers.setGrantOfAsylum(grantOfAsylum);

        const validator = new IsGrantOfAsylumExpiredValidator();
        expect(validator.validate(papers)).toBeFalsy();
    });
});import {AbstractControl, NG_VALIDATORS, Validator, ValidatorFn} from "@angular/forms";
import {Directive, Input} from "@angular/core";
import {ObjectUtil}


asOrigin for Ray {
    fn get_origin(&self) -> P2 {
        self.origin
    }
    fn set_origin(&mut self, origin: P2) {
        self.origin = origin;
    }
}

impl HasDirection for Ray {
    fn get_direction(&self) -> U2 {
        self.direction
    }

    fn set_direction(&mut self, direction: U2) {
        self.normal = Unit::new_unchecked(V2::new(-direction.y, direction.x));
        self.direction = direction;
    }
}

impl HasNormal for Ray {
    fn get_normal(&self) -> Normal {
        self.normal
    }
    fn set_normal(&mut self, normal: Normal) {
        self.normal = normal;
        self.direction = Unit::new_unchecked(V2::new(normal.y, -normal.x));
    }
}

impl Scale for Ray {
    fn scale(&mut self, _scale_x: Float, _scale_y: Float) {}
    fn scale_position(&mut self, scale_x: Float, scale_y: Float) {
        self.origin.scale(scale_x, scale_y);
    }
}

impl Mirror for Ray {
    fn mirror_x(&self) -> Self {
        Ray {
            origin: self.origin,
            normal: Normal::new_unchecked(V2::new(-self.normal.x, self.normal.y)),
            direction: U2::new_unchecked(V2::new(-self.direction.x, self.direction.y)),
        }
    }
    fn mirror_y(&self) -> Self {
        Ray {
            origin: self.origin,
            normal: Normal::new_unchecked(V2::new(self.normal.x, -self.normal.y)),
            direction: U2::new_unchecked(V2::new(self.direction.x, -self.direction.y)),
        }
    }
}

impl ClosestPoint for Ray {
    fn closest_point_to(&self, p: &P2) -> P2 {
        let po = p - self.origin;
        let r = self.direction.dot(&po);
        if r < 0. {
            self.origin
        } else {
            self.origin + r * self.get_direction().into_inner()
        }
    }
}

impl Distance for Ray {
    fn distance(&self, p: &P2) -> Float {
        let normal = self.get_normal();
        let amp = self.origin - p;
        let dist_ap = amp.norm();
        if amp.dot(&self.direction) > 0.0 {
            return dist_ap;
        }
        let dist_line = amp.dot(&normal).abs();
        dist_line.min(dist_ap)
    }
}

impl Distribution<Ray> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Ray {
        let a = rng.gen();
        let direction = rng.gen();
        Ray::from_origin(a, direction)
    }
}

impl HasGeometry for Ray {
    fn get_geometry(&self) -> Geo {
        Geo::GeoRay(*self)
    }
}

impl HasAabb for Ray {
    fn get_aabb(&self) -> Aabb {
        Aabb {
            origin: self.origin,
            width: 0.0,
            height: 0.0,
        }
    }
}

impl CanCollideWith<Line> for Ray {}
impl CanCollideWith<Ray> for Ray {}
impl CanCollideWith<LineSegment> for Ray {}
impl CanCollideWith<Circle> for Ray {}
impl CanCollideWith<Rect> for Ray {}
impl CanCollideWith<Aabb> for Ray {}
impl CanCollideWith<MCircle> for Ray {}

impl GeoT for Ray {}
use http::Uri;

use super::Address;

impl Address for Uri {
    fn hostname(&self) -> &str {
        self.host().unwrap_or("")
    }

    fn port(&self)


_particle_densities.clear();
        utils::reserve_total(node_particle_densities, node_particles.len());

        // Extract the particle densities of the leaf
        node_particle_densities.extend(
            node_particles
                .iter()
                .map(|&idx| global_particle_densities[idx]),
        );
    }
}

/// Computes per particle densities into the workspace, also performs the required neighborhood search
pub(crate) fn compute_particle_densities_and_neighbors<I: Index, R: Real>(
    grid: &UniformGrid<I, R>,
    particle_positions: &[Vector3<R>],
    parameters: &Parameters<R>,
    particle_neighbor_lists: &mut Vec<Vec<usize>>,
    densities: &mut Vec<R>,
) {
    profile!("compute_particle_densities_and_neighbors");

    let particle_rest_density = parameters.rest_density;
    let particle_rest_volume = R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap()
        * parameters.particle_radius.powi(3);
    let particle_rest_mass = particle_rest_volume * particle_rest_density;

    trace!("Starting neighborhood search...");
    neighborhood_search::search_inplace::<I, R>(
        &grid.aabb(),
        particle_positions,
        parameters.compact_support_radius,
        parameters.enable_multi_threading,
        particle_neighbor_lists,
    );

    trace!("Computing particle densities...");
    density_map::compute_particle_densities_inplace::<I, R>(
        particle_positions,
        particle_neighbor_lists.as_slice(),
        parameters.compact_support_radius,
        particle_rest_mass,
        parameters.enable_multi_threading,
        densities,
    );
}

/// Reconstruct a surface, appends triangulation to the given mesh
pub(crate) fn reconstruct_single_surface_append<'a, I: Index, R: Real>(
    workspace: &mut LocalReconstructionWorkspace<I, R>,
    grid: &UniformGrid<I, R>,
    subdomain_grid: Option<&OwningSubdomainGrid<I, R>>,
    particle_positions: &[Vector3<R>],
    particle_densities: Option<&[R]>,
    parameters: &Parameters<R>,
    output_mesh: &'a mut TriMesh3d<R>,
) -> Result<(), ReconstructionError<I, R>> {
    let particle_rest_density = parameters.rest_density;
    let particle_rest_volume = R::from_f64((4.0 / 3.0) * std::f64::consts::PI).unwrap()
        * parameters.particle_radius.powi(3);
    let particle_rest_mass = particle_rest_volume * particle_rest_density;

    let particle_densities = if let Some(particle_densities) = particle_densities {
        assert_eq!(particle_densities.len(), particle_positions.len());
        particle_densities
    } else {
        compute_particle_densities_and_neighbors(
            grid,
            particle_positions,
            parameters,
            &mut workspace.particle_neighbor_lists,
            &mut workspace.particle_densities,
        );
        workspace.particle_densities.as_slice()
    };

    // Create a new density map, reusing memory with the workspace is bad for cache efficiency
    // Alternatively one could reuse memory with a custom caching allocator
    let mut density_map = new_map().into();
    density_map::generate_sparse_density_map(
        grid,
        subdomain_grid,
        particle_positions,
        particle_densities,
        None,
        particle_rest_mass,
        parameters.compact_support_radius,
        parameters.cube_size,
        parameters.enable_multi_threading,


struct RegexBoyerMoore_t37ED99A3CC25068E4D3DE4517835CFFCCF2FA1EB  : public RuntimeObject
{
public:
	// System.Int32[] System.Text.RegularExpressions.RegexBoyerMoore::_positive
	Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ____positive_0;
	// System.Int32[] System.Text.RegularExpressions.RegexBoyerMoore::_negativeASCII
	Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ____negativeASCII_1;
	// System.Int32[][] System.Text.RegularExpressions.RegexBoyerMoore::_negativeUnicode
	Int32U5BU5DU5BU5D_tCA34E042D233821D51B4DAFB480EE602F2DBEF43* ____negativeUnicode_2;
	// System.String System.Text.RegularExpressions.RegexBoyerMoore::_pattern
	String_t* ____pattern_3;
	// System.Int32 System.Text.RegularExpressions.RegexBoyerMoore::_lowASCII
	int32_t ____lowASCII_4;
	// System.Int32 System.Text.RegularExpressions.RegexBoyerMoore::_highASCII
	int32_t ____highASCII_5;
	// System.Boolean System.Text.RegularExpressions.RegexBoyerMoore::_rightToLeft
	bool ____rightToLeft_6;
	// System.Boolean System.Text.RegularExpressions.RegexBoyerMoore::_caseInsensitive
	bool ____caseInsensitive_7;
	// System.Globalization.CultureInfo System.Text.RegularExpressions.RegexBoyerMoore::_culture
	CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ____culture_8;

public:
	inline static int32_t get_offset_of__positive_0() { return static_cast<int32_t>(offsetof(RegexBoyerMoore_t37ED99A3CC25068E4D3DE4517835CFFCCF2FA1EB, ____positive_0)); }
	inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get__positive_0() const { return ____positive_0; }
	inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of__positive_0() { return &____positive_0; }
	inline void set__positive_0(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
	{
		____positive_0 = value;
		Il2CppCodeGenWriteBarrier((void**)(&____positive_0), (void*)value);
	}

	inline static int32_t get_offset_of__negativeASCII_1() { return static_cast<int32_t>(offsetof(RegexBoyerMoore_t37ED99A3CC25068E4D3DE4517835CFFCCF2FA1EB, ____negativeASCII_1)); }
	inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get__negativeASCII_1() const { return ____negativeASCII_1; }
	inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of__negativeASCII_1() { return &____negativeASCII_1; }
	inline void set__negativeASCII_1(Int32U5BU


lag:before,
    .china .flag:after,
    .china .flag > div:before,
    .china .flag > div:after,
    .china .flag > div > div:before {
        //content: "★";
        content: "\2605";
        color: #FFDE00;
        position: absolute;
        font-size: 38px;
    }

    .china .flag:before {
        font-size: 105px;
        line-height: 105px;
        left: 7%;
        top: 15px;
        @include animation(fadeInDown 0.5s ease 1.5s both);
    }

    .china .flag:after {
        left: 30%;
        top: 0;
        @include transform(rotate(22deg));
        @include animation(fadeInLeft 0.5s ease 0.5s both);
    }

    .china .flag > div:before {
        left: 36%;
        top: 10%;
        @include transform(rotate(-21deg));
        @include animation(fadeInLeft 0.5s ease 0.75s both);
    }

    .china .flag > div:after {
        left: 36.5%;
        top: 25%;
        @include animation(fadeInLeft 0.5s ease 1s both);
    }

    .china .flag > div > div:before {
        left: 30%;
        top: 35%;
        @include transform(rotate(23deg));
        @include animation(fadeInLeft 0.5s ease 1.25s both);
    }/*  USA
    ========================================================================== */
    .usa { background-color: #88ddd2; }

    .usa .flag {
        @include vertical-gradient(#B22234, #B22234 50%, #ffffff 50%);
        @include background-size(100% 46px);
        @include animation(fadeInRight 1s cubic-bezier(0.175, 0.885, 0.320, 1.275) both);
    }

    .usa .flag:before {
        content: '';
        background-color: #3C3B6E;
        width: 40%;
        height: 54.5%;
        position: absolute;
        left: 0;
        top: 0;
        @include animation(fadeInDown 0.75s cubic-bezier(0.175, 0.885, 0.320, 1.275) both 0.5s);
    }

    .usa .flag .star:before,
    .usa .flag .star:after {
        //content: "★";
        content: "\2605";
        font-size: 19px;
        color: #fff;
        position: absolute;
    }

    .usa .star-01:before  { left: 2%;    top: 0;    }
    .usa .star-01:after   { left: 2%;    top: 11%;  }
    .usa .star-02:before  { left: 2%;    top: 22%;  }
    .usa .star-02:after   { left: 2%;    top: 33%;  }
    .usa .star-03:before  { left: 2%;    top: 44%;  }
    .usa .star-03:after   { left: 5%;    top: 5%;   }
    .usa .star-04:before  { left: 5%;    top: 16%;  }
    .usa .star-04:after   { left: 5%;    top: 27%;  }
    .usa .star-05:before  { left: 5%;    top: 38%;  }
    .usa .star-05:after   { left: 8.5%;  top: 0;    }
    .usa .star-06:before  { left: 8.5%;  top: 11%;  }
    .usa .star-06:after   { left


        } else {
            if (!this.quadTrees.length) {
                this.subdivide()
            }
            for (var i = 0; i < this.quadTrees.length; i++) {
                if (this.quadTrees[i].insert(point)) {
                    return true
                }
            }
        }
    }

    subdivide() {
        const { x, y, w, h, capacity } = this
        const tw = w / h
        const iw = w / tw

        if (tw === 1) {
            this.quadTrees = [
                new QuadTree(x, y, w / 2, h / 2, capacity),
                new QuadTree(x + w / 2, y, w / 2, h / 2, capacity),
                new QuadTree(x, y + h / 2, w / 2, h / 2, capacity),
                new QuadTree(x + w / 2, y + h / 2, w / 2, h / 2, capacity)
            ]
        } else {
            for (var i = 0; i < tw; i++) {
                this.quadTrees.push(new QuadTree(x + i * iw, y, iw, h, capacity))
            }
        }
    }

    render(qt_ctx: CanvasRenderingContext2D) {
        if (!this.points.length) {
            return
        }
        const { x, y, w, h } = this
        qt_ctx.fillRect(x, y, 1, h)
        qt_ctx.fillRect(x, y, w, 1)
        qt_ctx.fillRect(x + w - 1, y, 1, h)
        qt_ctx.fillRect(x, y + h - 1, w, 1)
        this.quadTrees.forEach((qt: QuadTree) => {
            qt.render(qt_ctx)
        })
    }

    debugRender(qt_ctx: CanvasRenderingContext2D) {
        if (!this.points.length) {
            return
        }
        const { x, y, w, h } = this
        qt_ctx.fillRect(x, y, 1, h)
        qt_ctx.fillRect(x, y, w, 1)
        qt_ctx.fillRect(x + w - 1, y, 1, h)
        qt_ctx.fillRect(x, y + h - 1, w, 1)
        this.quadTrees.forEach((qt: QuadTree) => {
            qt.debugRender(qt_ctx)
        })
    }

    query(range: Boundry): Boundry[] {
        if (!this.intersects(range)) {
            return []
        }

        let found: Boundry[] = this.points.filter((point: Boundry) => {
            return range.intersects(point)
        })

        for (var i = 0; i < this.quadTrees.length; i++) {
            let sub_query = this.quadTrees[i].query(range)
            if (sub_query.length) {
                found.concat(sub_query)
                // Uncomment this if objects do not cross several subdivides.
                // break
            }
        }

        if (found.length) {
            const { x, y, w, h } = this
            // @ts-ignore
            qt_ctx.globalAlpha = 0.1
            // @ts-ignore
            qt_ctx.fillStyle = Helper.rgb(255, 255, 255)
            // @ts-ignore
            qt_ctx.fillText(`${this.points.length}/${this.capacity}`, x + w / 2 - 4, y + h / 2 + 6)
            // @ts-ignore
            qt_ctx.fillRect(x, y, w, 1)
            // @ts-ignore
            qt_ctx.fillRect(x, y, 1, h)
            // @ts-ignore
            qt_ctx.fillRect(x, y + h - 1, w, 1)
            // @ts-ignore
            qt_ctx.fillRect(x + w - 1, y, 1, h)
            // @ts-ignore
            qt_ctx.globalAlpha = 1.0
        }

        return found
    }

}
import express = require("express");
import socketio = require("so


드 은행 스킨을 업데이트했습니다.",
			"[진행도] 시즌 3 콘텐츠를 업데이트했습니다.",
			"[파티 찾기] 시즌 3 콘텐츠를 업데이트했습니다.",
			"[세계 지도] 업데이트된 안개 제거 데이터베이스.",
			"[추가 아이템 바] 잠재적인 Lua 오류를 수정했습니다.",
		},
		["ruRU"] = {
			"Оптимизированы некоторые описания и переводы.",
			"[Перемещение фреймов] Рефакторинг логики перемещения фреймов, попытка исправить ошибки, которые могут возникнуть при перемещении во время боя.",
			"[Скины] Обновлен скин банка ElvUI.",
			"[Скины] Обновлен скин банка Blizzard.",
			"[Прогресс] Обновлен контент 3-го сезона.",
			"[Поиск группы] Обновлен контент 3-го сезона.",
			"[Мировая карта] Обновлена база данных удаления тумана.",
			"[Дополнительные элементы интерфейса] Исправлены потенциальные ошибки Lua.",
		},
	},
}


axX = 0
        var maxY = 0
        val pixels = IntArray(bitmap.width * bitmap.height)
        bitmap.getPixels(pixels, 0, bitmap.width, 0, 0, bitmap.width, bitmap.height)

        for (y in 0 until height) {
            for (x in 0 until width) {
                val index = y * width + x
                val conf = (1.0f - bgConf[index]) * 255
                if (conf >= 100) {
                    bitmap.setPixel(x, y, Color.TRANSPARENT)
                } else {
                    if (pixels[x + y * bitmap.width] != Color.TRANSPARENT) {
                        minX = minOf(minX, x)
                        minY = minOf(minY, y)
                        maxX = maxOf(maxX, x)
                        maxY = maxOf(maxY, y)
                    }
                }
            }
        }

        val cropWidth = maxX - minX + 1
        val cropHeight = maxY - minY + 1
        if (cropWidth <= 0 || cropHeight <= 0) {
            return bitmap
        }

        return Bitmap.createBitmap(bitmap, minX, minY, cropWidth, cropHeight)
    }

    private fun makeBackgroundTransparent(bitmap: Bitmap, bgConf: FloatArray) {
        for (y in 0 until bitmap.height) {
            for (x in 0 until bitmap.width) {
                val index = y * bitmap.width + x
                val conf = (1.0f - bgConf[index]) * 255
                if (conf >= 100) {
                    bitmap.setPixel(x, y, Color.TRANSPARENT)
                }
            }
        }
    }

    private fun sendErrorResult(result: MethodChannel.Result, status: Int, errorMessage: String?) {
        val errorResult = mapOf(
            "status" to status,
            "message" to errorMessage
        )
        result.success(errorResult)
    }

    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
        channel.setMethodCallHandler(null)
    }

    override fun onAttachedToActivity(binding: ActivityPluginBinding) {
        activity = binding.activity as AppCompatActivity
    }

    override fun onDetachedFromActivity() {
        activity = null
    }

    override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
        activity = binding.activity as AppCompatActivity
    }

    override fun onDetachedFromActivityForConfigChanges() {
        activity = null
    }
}
package com.example.learn.business

import android.content.Context
import android.support.constraint.ConstraintLayout
import android.util.AttributeSet
import android.view.LayoutInflater
import com.example.learn.R
import com.example.learn.view.AnimationUpdateListener
import com.example.learn.view.stateRefresh
import com.example.learn.view.stateSave
import com.example.learn.text
import kotlinx.android.synthetic.main.ticket_view.view.*

class TicketView(context: Context, attrs: AttributeSet?) : ConstraintLayout(context, attrs), AnimationUpdateListener {

    private var firstLayout: Boolean = false

    init {
        LayoutInflater.from(context).inflate(R.layout.ticket_view, this)
    }

    override fun onWindowFocusChanged(hasWindowFocus: Boolean) {
        super.onWindowFocusChanged(hasWindowFocus)
        if (!firstLayout) {
            firstLayout = true
            vBorder1.stateSave(R.id.vs1).a(1F)
            vBorder1.stateSave(R.id.vs2).ws(3.8F).hs(3.8F).a(0F)
            vBorder2.stateSave(R.id.vs1).a(0F)
            vBorder2.stateSave(R.id.vs2).ws(3.8F).hs(3.8F).a(1F)
            vSimple.stateSave(R.id.vs1)
            vSimple.stateSave(R.id.vs2).a(0f)
            layDetail.stateSave(R.id.vs1)
            layDetail.stateSave(R.id.vs2).sx(1F).sy(1F).a(1F)
        }
    }

    fun set(amount: Int, limit: Int, expireTime: String) {
        vSimple.text("领￥$amount")

        vDetail1.text("￥$amount")
        vDetail2.text("满$limit 可用")
        vDetail3.text("有效期


00i8 };
SECTION void* _off_5FD50C = __ptr(0x5FD4FC, 0);
SECTION char _data_5FD510[0x10] = { /* 0 [0x10] */ };
SECTION char _data_5FD520[0x4] = { 0xFFi8, 0xFFi8, 0xFFi8, 0xFFi8 };
SECTION void* _off_5FD524 = __ptr_func(0x5C3820, 0);
SECTION char _data_5FD528[0x4] = { /* 0 [0x4] */ };
SECTION void* _off_5FD52C = __ptr_func(0x5C3828, 0);
SECTION char _data_5FD530[0x4] = { 0x01i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD534 = __ptr_func(0x5C3836, 0);
SECTION char _data_5FD538[0x4] = { 0x02i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD53C = __ptr_func(0x5C3844, 0);
SECTION char _data_5FD540[0x4] = { 0x03i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD544 = __ptr_func(0x5C3852, 0);
SECTION char _data_5FD548[0x4] = { 0x04i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD54C = __ptr_func(0x5C3860, 0);
SECTION char _data_5FD550[0x4] = { 0x05i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD554 = __ptr_func(0x5C386E, 0);
SECTION char _data_5FD558[0x4] = { 0x06i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD55C = __ptr_func(0x5C387C, 0);
SECTION char _data_5FD560[0x8] = { 0x20i8, 0x05i8, 0x93i8, 0x19i8, 0x08i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD568 = __ptr(0x5FD520, 0);
SECTION char _data_5FD56C[0x10] = { /* 0 [0x10] */ };
SECTION char _data_5FD57C[0x4] = { 0xFFi8, 0xFFi8, 0xFFi8, 0xFFi8 };
SECTION void* _off_5FD580 = __ptr_func(0x5C38A0, 0);
SECTION char _data_5FD584[0x4] = { /* 0 [0x4] */ };
SECTION void* _off_5FD588 = __ptr_func(0x5C38A9, 0);
SECTION char _data_5FD58C[0x4] = { 0xFFi8, 0xFFi8, 0xFFi8, 0xFFi8 };
SECTION void* _off_5FD590 = __ptr_func(0x5C38B1, 0);
SECTION char _data_5FD594[0x4] = { 0x02i8, 0x00i8, 0x00i8, 0x00i8 };
SECTION void* _off_5FD598 = __ptr_func(0x5C38BA, 0);
SECTION char _data_5FD59C[0x4] = { 0xFFi8, 0xFFi8, 0xFFi8, 0xFFi8 };
SECT


  }
}
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'device_info_repository.dart';

// **************************************************************************
// RiverpodGenerator
// **************************************************************************

// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning

@ProviderFor(deviceInfoRepository)
const deviceInfoRepositoryProvider = DeviceInfoRepositoryProvider._();

final class DeviceInfoRepositoryProvider
    extends
        $FunctionalProvider<
          DeviceInfoRepository,
          DeviceInfoRepository,
          DeviceInfoRepository
        >
    with $Provider<DeviceInfoRepository> {
  const DeviceInfoRepositoryProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'deviceInfoRepositoryProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$deviceInfoRepositoryHash();

  @$internal
  @override
  $ProviderElement<DeviceInfoRepository> $createElement(
    $ProviderPointer pointer,
  ) => $ProviderElement(pointer);

  @override
  DeviceInfoRepository create(Ref ref) {
    return deviceInfoRepository(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(DeviceInfoRepository value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<DeviceInfoRepository>(value),
    );
  }
}

String _$deviceInfoRepositoryHash() =>
    r'dcaf3408a6f9af373195720fa6acd3fa19a327a3';
// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'file_repository.dart';

// **************************************************************************
// RiverpodGenerator
// **************************************************************************

// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning

@ProviderFor(fileRepository)
const fileRepositoryProvider = FileRepositoryProvider._();

final class FileRepositoryProvider
    extends $FunctionalProvider<FileRepository, FileRepository, FileRepository>
    with $Provider<FileRepository> {
  const FileRepositoryProvider._()
    : super(
        from: null,
        argument: null,
        retry: null,
        name: r'fileRepositoryProvider',
        isAutoDispose: false,
        dependencies: null,
        $allTransitiveDependencies: null,
      );

  @override
  String debugGetCreateSourceHash() => _$fileRepositoryHash();

  @$internal
  @override
  $ProviderElement<FileRepository> $createElement($ProviderPointer pointer) =>
      $ProviderElement(pointer);

  @override
  FileRepository create(Ref ref) {
    return fileRepository(ref);
  }

  /// {@macro riverpod.override_with_value}
  Override overrideWithValue(FileRepository value) {
    return $ProviderOverride(
      origin: this,
      providerOverride: $SyncValueProvider<FileRepository>(value),
    );
  }
}

String _$fileRepositoryHash() => r'e455678270274497fd0eb91aafc6d3422900b4e4';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'shared_preference_key.dart';

part 'shared_preference_repository.g.dart';

@Riverpod(keepAlive: true)
SharedPreferencesRepository sharedPreferencesRepository(Ref ref) {
  throw UnimplementedError();
}

class SharedPreferencesRepository {
  SharedPreferencesRepository(this._prefs);

  final SharedPreferencesWithCache _prefs;

  Future<void> save<T>(SharedPreferencesKey key, T value) {
    if (value is int) {
      return _prefs.setInt(key.value, value)


]} {translator.get('oauth.auth_update_success') if translator else 'Auth update success'}{Style.RESET_ALL}")
            # Close the browser after successful authentication
            if handler.browser:
                handler.browser.quit()
                print(f"{Fore.CYAN}{EMOJI['INFO']} {translator.get('oauth.browser_closed') if translator else 'Browser closed'}{Style.RESET_ALL}")
            return True
        else:
            print(f"{Fore.RED}{EMOJI['ERROR']} {translator.get('oauth.auth_update_failed') if translator else 'Auth update failed'}{Style.RESET_ALL}")

    return False


);
}

TEST(LogTest, UnexpectedMiddleType) {
  Write("foo");
  SetByte(6, kMiddleType);
  FixChecksum(0, 3);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
}

TEST(LogTest, UnexpectedLastType) {
  Write("foo");
  SetByte(6, kLastType);
  FixChecksum(0, 3);
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("missing start"));
}

TEST(LogTest, UnexpectedFullType) {
  Write("foo");
  Write("bar");
  SetByte(6, kFirstType);
  FixChecksum(0, 3);
  ASSERT_EQ("bar", Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("partial record without end"));
}

TEST(LogTest, UnexpectedFirstType) {
  Write("foo");
  Write(BigString("bar", 100000));
  SetByte(6, kFirstType);
  FixChecksum(0, 3);
  ASSERT_EQ(BigString("bar", 100000), Read());
  ASSERT_EQ("EOF", Read());
  ASSERT_EQ(3, DroppedBytes());
  ASSERT_EQ("OK", MatchError("partial record without end"));
}

TEST(LogTest, ErrorJoinsRecords) {
  // Consider two fragmented records:
  //    first(R1) last(R1) first(R2) last(R2)
  // where the middle two fragments disappear.  We do not want
  // first(R1),last(R2) to get joined and returned as a valid record.

  // Write records that span two blocks
  Write(BigString("foo", kBlockSize));
  Write(BigString("bar", kBlockSize));
  Write("correct");

  // Wipe the middle block
  for (int offset = kBlockSize; offset < 2*kBlockSize; offset++) {
    SetByte(offset, 'x');
  }

  ASSERT_EQ("correct", Read());
  ASSERT_EQ("EOF", Read());
  const int dropped = DroppedBytes();
  ASSERT_LE(dropped, 2*kBlockSize + 100);
  ASSERT_GE(dropped, 2*kBlockSize);
}

TEST(LogTest, ReadStart) {
  CheckInitialOffsetRecord(0, 0);
}

TEST(LogTest, ReadSecondOneOff) {
  CheckInitialOffsetRecord(1, 1);
}

TEST(LogTest, ReadSecondTenThousand) {
  CheckInitialOffsetRecord(10000, 1);
}

TEST(LogTest, ReadSecondStart) {
  CheckInitialOffsetRecord(10007, 1);
}

TEST(LogTest, ReadThirdOneOff) {
  CheckInitialOffsetRecord(10008, 2);
}

TEST(LogTest, ReadThirdStart) {
  CheckInitialOffsetRecord(20014, 2);
}

TEST(LogTest, ReadFourthOneOff) {
  CheckInitialOffsetRecord(20015, 3);
}

TEST(LogTest, ReadFourthFirstBlockTrailer) {
  CheckInitialOffsetRecord(log::kBlockSize - 4, 3);
}

TEST(LogTest, ReadFourthMiddleBlock) {
  CheckInitialOffsetRecord(log::kBlockSize + 1, 3);
}

TEST(LogTest, ReadFourthLastBlock) {
  CheckInitialOffsetRecord(2 * log::kBlockSize + 1, 3);
}

TEST(LogTest, ReadFourthStart) {
  CheckInitialOffsetRecord(
      2 * (kHeaderSize + 1000) + (2 * log::kBlockSize - 1000) + 3 * kHeaderSize,
      3);
}

TEST(LogTest, ReadEnd) {
  CheckOffsetPastEndReturnsNoRecords(0);
}

TEST(LogTest, ReadPastEnd) {
  CheckOffsetPastEndReturnsNoRecords(5);
}

}  // namespace log