----组策略
- explorer------资源管理器
- chkdsk.exe------Chkdsk磁盘检查
- dcomcnfg------系统组件服务
- devmgmt.msc------设备管理器
- cleanmgr------垃圾整理
- compmgmt.msc------计算机管理
- secpol.msc------本地安全策略
- netstat -an------(TC)命令检查接口
- taskmgr------任务管理器
- mmc------控制台
- lusrmgr.msc------本机用户和组
- dvdplay------DVD播放器
- diskmgmt.msc------磁盘管理实用程序
- dxdiag------检查DirectX信息
- perfmon.msc------计算机性能检测程序
- winver------检测Windows版本
- write------写字板
- wiaacmgr------扫描仪和照相机向导
- mspaint------画图板
- magnify------放大镜实用程序
- utilman------辅助工具管理器
- osk------屏幕键盘
- odbcad32------ODBC数据源管理器
- Sndvol------音量控制程序
- sfc.exe------系统文件检查器
- sfc /scannow------Windows文件保护
- eventvwr------事件查看器
# MariaDB

mysql被收购后衍生的分支，由社区维护。

1. 安装mariadb（一些发行版可能将server和client分开打包）

2. 可选，执行以下命令进行初始化：

   ```shell
   #指定运行用户和数据存放位置
   mysql_install_db --user=mysql --datadir=/var/lib/mysql  --basedir=/var/lib/mysql --datadir=/var/lib/mysql/data

   #mariadb
   mariadb-install-db --user=mysql --basedir=/usr --datadir=/var/lib/mysql
   ```

   `mysql_install_db`将把数据库存放目录的权限所有者改为mysql用户当前用户。

   如果启动提示：

   >  Can't open and lock privilege tables: Table 'mysql.servers' doesn't exist

   则是制定的数据库位置中没有初始化的数据库，使用上面的命令初始化即可。

   mariadb安装后，系统会创建mysql用户用作运行mariadb的默认用户，`--user=mysql`会将数据库存放目录的权限所有者改为mysql用户；如果要使用mysql运行，但当前用户不是`mysql`且没有使用`--user=mysql`，需要修改数据库文件权限：

   ```shell
   chown -R mysql:mysql /var/lib/mysql
   ```

   使用systemctl启动mariadb会自动初始化数据库目录，具体查看其systemd unit文件。

3. 启动mariadb服务

   ```shell
   systemctl enable --now mariadb
   ```

   如果不使用systemctl，使用mysqld_safe（一个脚本，systemd units也是执行该脚本）启动：

   ```shell
   mysqld_safe  # --datadir='/var/lib/mysql'
   mysqld_safe #--defaults-file=xx.cnf
   ```

   可使用`--defaults-file`指定读取的配置文件（默认读取`/etc/my.conf`）。

4. 安全配置，可选

   ```shell
   mysql_secure_installation
   ```

   其会询问用户作出一些安全性相关的设置建议，主要包括：

   - 是否设置root密码
   - 是否关闭远程root登录
   - 是否删除匿名帐号（实际匿名用户是没有任何权限的）
   - 是否删除测试数据库test

   或者使用sql：

   ```sql
   use mysql;
   --:del root remote access
   delete from user where user='root' and host!='localhost';


ences.set("Key6" to true)
    preferences.set("Key7" to JsonSerializable("test"))

    assertEquals("Value", preferences.getString("Key1"))
    assertEquals(1, preferences.getInteger("Key2"))
    assertEquals(2L, preferences.getLong("Key3"))
    assertEquals(3.0f, preferences.getFloat("Key4"))
    assertEquals(4.0f, preferences.getFloat("Key5"))
    assertEquals(true, preferences.getBoolean("Key6"))
    assertEquals(
      JsonSerializable("test"),
      Json().fromJson(JsonSerializable::class.java, preferences.getString("Key7")),
    )
  }

  @Test(expected = GdxRuntimeException::class)
  fun `should throw an exception when setting double value outside of float range as pair`() {
    preferences.set("Key" to Double.MAX_VALUE)
  }

  @Test
  fun `should set any value`() {
    preferences["Key"] = JsonSerializable("test")

    assertTrue("Key" in preferences)
    assertEquals(
      JsonSerializable("test"),
      Json().fromJson(JsonSerializable::class.java, preferences.getString("Key")),
    )
  }

  @Test
  fun `should get string value`() {
    preferences["Key"] = "Value"

    val result: String? = preferences["Key"]

    assertEquals("Value", result)
  }

  @Test
  fun `should get boolean value`() {
    preferences["Key"] = true

    val result: Boolean? = preferences["Key"]

    assertEquals(true, result)
  }

  @Test
  fun `should get int value`() {
    preferences["Key"] = 1

    val result: Int? = preferences["Key"]

    assertEquals(1, result)
  }

  @Test
  fun `should get float value`() {
    preferences["Key"] = 1f

    val result: Float? = preferences["Key"]

    assertEquals(1f, result)
  }

  @Test
  fun `should get long value`() {
    preferences["Key"] = 1L

    val result: Long? = preferences["Key"]

    assertEquals(1L, result)
  }

  @Test
  fun `should get any value`() {
    preferences["Key"] = JsonSerializable("test")

    val result: JsonSerializable? = preferences["Key"]

    assertEquals(JsonSerializable("test"), result)
  }

  @Test
  fun `should get missing string value`() {
    val result: String? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get missing boolean value`() {
    val result: Boolean? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get missing int value`() {
    val result: Int? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get missing float value`() {
    val result: Float? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get missing long value`() {
    val result: Long? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get missing object value`() {
    val result: JsonSerializable? = preferences["Key"]

    assertNull(result)
  }

  @Test
  fun `should get string with default value`() {
    preferences["Key"] = "Value"

    val result: String = preferences["Key", "default"]

    assertEquals("Value", result)
  }

  @Test
  fun `should get boolean with default value`() {
    preferences["Key"] = true

    val result: Boolean = preferences["Key", false]

    assertEquals(true, result)
  }

  @Test
  fun `should get int with default value`() {
    preferences["Key"] = 1

    val result: Int = preferences["Key", 0]

    assertEquals(1,


 (and other patterns), make
    // an assumption that the decoded string must be a 'standard' length if it's short
    final length = resultString.length;
    bool lengthOK = false;
    int maxAllowedLength = 0;
    for (int allowedLength in allowedLengths) {
      if (length == allowedLength) {
        lengthOK = true;
        break;
      }
      if (allowedLength > maxAllowedLength) {
        maxAllowedLength = allowedLength;
      }
    }
    if (!lengthOK && length > maxAllowedLength) {
      lengthOK = true;
    }
    if (!lengthOK) {
      throw FormatsException.instance;
    }

    final resultObject = Result(
      resultString,
      null, // no natural byte representation for these barcodes
      [
        ResultPoint(startRange[1].toDouble(), rowNumber.toDouble()),
        ResultPoint(endRange[0].toDouble(), rowNumber.toDouble()),
      ],
      BarcodeFormat.itf,
    );
    resultObject.putMetadata(ResultMetadataType.symbologyIdentifier, ']I0');
    return resultObject;
  }

  /// @param row          row of black/white values to search
  /// @param payloadStart offset of start pattern
  /// @param resultString [StringBuffer] to append decoded chars to
  /// @throws NotFoundException if decoding could not complete successfully
  static void _decodeMiddle(
    BitArray row,
    int payloadStart,
    int payloadEnd,
    StringBuffer resultString,
  ) {
    // Digits are interleaved in pairs - 5 black lines for one digit, and the
    // 5
    // interleaved white lines for the second digit.
    // Therefore, need to scan 10 lines and then
    // split these into two arrays
    final counterDigitPair = List.filled(10, 0);
    final counterBlack = List.filled(5, 0);
    final counterWhite = List.filled(5, 0);

    while (payloadStart < payloadEnd) {
      // Get 10 runs of black/white.
      OneDReader.recordPattern(row, payloadStart, counterDigitPair);
      // Split them into each array
      for (int k = 0; k < 5; k++) {
        final twoK = 2 * k;
        counterBlack[k] = counterDigitPair[twoK];
        counterWhite[k] = counterDigitPair[twoK + 1];
      }

      int bestMatch = _decodeDigit(counterBlack);
      resultString.writeCharCode(48 /* 0 */ + bestMatch);
      bestMatch = _decodeDigit(counterWhite);
      resultString.writeCharCode(48 /* 0 */ + bestMatch);

      for (int counterDigit in counterDigitPair) {
        payloadStart += counterDigit;
      }
    }
  }

  /// Identify where the start of the middle / payload section starts.
  ///
  /// @param row row of black/white values to search
  /// @return Array, containing index of start of 'start block' and end of
  ///         'start block'
  List<int> _decodeStart(BitArray row) {
    final endStart = _skipWhiteSpace(row);
    final startPattern = _findGuardPattern(row, endStart, _startPattern);

    // Determine the width of a narrow line in pixels. We can do this by
    // getting the width of the start pattern and dividing by 4 because its
    // made up of 4 narrow lines.
    _narrowLineWidth = (startPattern[1] - startPattern[0]) ~/ 4;

    _validateQuietZone(row, startPattern[


rsion OWC10 1
		 /// </summary>
		 /// <remarks>9</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeDays = 9,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>10</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeHours = 10,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>11</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeMinutes = 11,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>12</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeSeconds = 12,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>13</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeUndefined = 13,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>14</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeUnknown = 14,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>15</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeUserDefined = 15,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>16</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeTimeWeekdays = 16,

		 /// <summary>
		 /// SupportByVersion OWC10 1
		 /// </summary>
		 /// <remarks>17</remarks>
		 [SupportByVersion("OWC10", 1)]
		 plTypeCustomGroup = 17
	}
}


"""
'analog_in.py'
==================================
Example of sending analog sensor
values to an Adafruit IO feed.

Author(s): Brent Rubell

Dependencies:
    - Adafruit_Blinka
        (https://github.com/adafruit/Adafruit_Blinka)
    - Adafruit_CircuitPython_MCP3xxx
        (https://github.com/adafruit/Adafruit_CircuitPython_MCP3xxx)
"""
# Import standard python modules
import time

# import Adafruit Blinka
import board
import digitalio
import busio

# import Adafruit IO REST client
from Adafruit_IO import Client, Feed, RequestError

# import Adafruit CircuitPython MCP3xxx library
from adafruit_mcp3xxx.mcp3008 import MCP3008
from adafruit_mcp3xxx.analog_in import AnalogIn

# Set to your Adafruit IO key.
# Remember, your key is a secret,
# so make sure not to publish it when you publish this code!
ADAFRUIT_IO_KEY = 'YOUR_AIO_KEY'

# Set to your Adafruit IO username.
# (go to https://accounts.adafruit.com to find your username)
ADAFRUIT_IO_USERNAME = 'YOUR_AIO_USERNAME'
# Create an instance of the REST client
aio = Client(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY)

try: # if we have a 'analog' feed
    analog = aio.feeds('analog')
except RequestError: # create a analog feed
    feed = Feed(name='analog')
    analog = aio.create_feed(feed)

# Create an instance of the `busio.spi` class
spi = busio.SPI(board.SCLK, board.MOSI, board.MISO)

# create the cs (chip select)
cs = digitalio.DigitalInOut(board.D12)

# create a mcp3008 object
mcp = MCP3008(spi, cs)

# create an an adc (single-ended) on pin 0
chan = AnalogIn(mcp, MCP3008.pin_0)

while True:
    sensor_data = chan.value

    print('Analog Data -> ', sensor_data)
    aio.send(analog.key, sensor_data)

    # avoid timeout from adafruit io
    time.sleep(0.5)


        period = whatTime.timePair.first.minutesUntil(whatTime.timePair.second),
        week = whatTime.date.map {
          it.year * 10000 + it.monthNumber * 100 + it.dayOfMonth
        }
      )
    }.let {
      defaultJson.encodeToString(it)
    }
  }

  private fun checkStuNum(oldStuNum: String?) {
    val newStuNum = IAccountService::class.impl().stuNum
    if (newStuNum != oldStuNum) {
      throw StuNumNotMatchException(oldStuNum, newStuNum)
    }
  }

  private class StuNumNotMatchException(
    oldStuNum: String?,
    newStuNum: String?
  ) : IllegalStateException("旧学号 $oldStuNum 与新学号 $newStuNum 不匹配")
}package com.cyxbs.pages.widget.repo.bean

import androidx.room.Entity
import androidx.room.PrimaryKey
import com.cyxbs.pages.course.api.ILessonService
import java.io.Serializable

/**
 * author : Watermelon02
 * email : 1446157077@qq.com
 */
@Entity
data class LessonEntity(
    val stuNum: String = "",
    val week: Int = 0, // 第几周的课
    val beginLesson: Int = 0, // 开始节数，如：1、2 节课以 1 开始；3、4 节课以 3 开始，注意：中午是以 -1 开始，傍晚是以 -2 开始
    val classroom: String = "", // 教室
    val course: String = "", // 课程名
    val courseNum: String = "", // 课程号
    val day: String = "", // 星期几，这是字符串的星期几：星期一、星期二......
    val hashDay: Int = 0, // 星期数，星期一为 0
    var period: Int = 2, // 课的长度
    val rawWeek: String = "", // 周期
    val teacher: String = "",
    val type: String = "", // 选修 or 必修
    @PrimaryKey
    val id: String = "${stuNum}-${week}-${hashDay}-${beginLesson}",
) : Serializable {
    companion object {
        //将api模块的Lesson转化为widget模块的Lesson
        fun convertFromApi(apiLessons: List<ILessonService.Lesson>): ArrayList<LessonEntity> {
            val lessons = arrayListOf<LessonEntity>()
            for (apiLesson in apiLessons) {
                val lesson = LessonEntity(
                    stuNum = apiLesson.stuNum,
                    week = apiLesson.week,
                    beginLesson = apiLesson.beginLesson,
                    classroom = apiLesson.classroom,
                    course = apiLesson.course,
                    courseNum = apiLesson.courseNum,
                    day = apiLesson.day,
                    hashDay = apiLesson.hashDay,
                    period = apiLesson.period,
                    rawWeek = apiLesson.rawWeek,
                    teacher = apiLesson.teacher,
                    type = apiLesson.type)
                lessons.add(lesson)
            }
            return lessons
        }

        fun LessonEntity.convertToApi(): ILessonService.Lesson {
            return ILessonService.Lesson(
                stuNum = this.stuNum,
                week = this.week,
                beginLesson = this.beginLesson,
                classroom = this.classroom,
                course = this.course,
                courseNum = this.courseNum,
                da


p>是的，您可以在多個 Milvus 實例中共用一個 etcd 實例。要做到這一點，您需要在啟動每個 Milvus 實例之前，將etcd.rootPath 改為每個實例配置文件中的單獨值。

我可以在多個 Milvus 實例中共用一個 Pulsar 實例嗎？

是的，您可以在多個 Milvus 實例之間共享一個 Pulsar 實例。要這樣做，你可以

如果在你的 Pulsar 实例上启用了多租户，考虑为每个 Milvus 实例分配一个单独的租户或命名空间。要做到這一點，您需要在啟動 Milvus 實例之前，將其配置檔中的pulsar.tenant 或pulsar.namespace 改為每個實例的唯一值。

如果您不打算在 Pulsar 實例上啟用多租戶功能，請考慮在啟動 Milvus 實例之前，將配置檔案中的msgChannel.chanNamePrefix.cluster 變更為每個實例的唯一值。

我可以在多個 Milvus 實例中共用一個 MinIO 實例嗎？

是的，您可以在多個 Milvus 實體之間共用一個 MinIO 實體。要做到這一點，您需要在啟動每個 Milvus 實例之前，將minio.rootPath 改為每個 Milvus 實例配置文件中的唯一值。

如何處理pymilvus.exceptions.ConnectionConfigException: <ConnectionConfigException: (code=1, message=Illegal uri: [example.db], expected form 'https://user:pwd@example.com:12345')> 錯誤訊息？

錯誤訊息Illegal uri [example.db] 表示您嘗試使用早期版本的 PyMilvus 連線到 Milvus Lite，而早期版本的 PyMilvus 並不支援此連線類型。要解決這個問題，請將你的 PyMilvus 安裝


DateTime get pillSheetCreatedAt;
  @override

  /// 作成されたピルシートのIDリスト（非推奨）
  /// 複数シート同時作成に対応するためのIDリスト
  List<String> get pillSheetIDs;
  @override
  @JsonKey(ignore: true)
  _$$CreatedPillSheetValueImplCopyWith<_$CreatedPillSheetValueImpl> get copyWith => throw _privateConstructorUsedError;
}

AutomaticallyRecordedLastTakenDateValue _$AutomaticallyRecordedLastTakenDateValueFromJson(Map<String, dynamic> json) {
  return _AutomaticallyRecordedLastTakenDateValue.fromJson(json);
}

/// @nodoc
mixin _$AutomaticallyRecordedLastTakenDateValue {
// The below properties are deprecated and added since v1.
// This is deprecated property. TODO: [PillSheetModifiedHistory-V2] delete after 2024-05-01
  /// 変更前の最終服用日（非推奨、nullable）
  /// 初回服用の場合はnullとなる
  @JsonKey(fromJson: TimestampConverter.timestampToDateTime, toJson: TimestampConverter.dateTimeToTimestamp)
  DateTime? get beforeLastTakenDate => throw _privateConstructorUsedError;

  /// 変更後の最終服用日（非推奨）
  /// 自動記録によって設定された新しい最終服用日
  @JsonKey(fromJson: NonNullTimestampConverter.timestampToDateTime, toJson: NonNullTimestampConverter.dateTimeToTimestamp)
  DateTime get afterLastTakenDate => throw _privateConstructorUsedError;

  /// 変更前の最終服用ピル番号（非推奨）
  /// 自動記録前のピル番号
  int get beforeLastTakenPillNumber => throw _privateConstructorUsedError;

  /// 変更後の最終服用ピル番号（非推奨）
  /// 自動記録後のピル番号
  int get afterLastTakenPillNumber => throw _privateConstructorUsedError;

  Map<String, dynamic> toJson() => throw _privateConstructorUsedError;
  @JsonKey(ignore: true)
  $AutomaticallyRecordedLastTakenDateValueCopyWith<AutomaticallyRecordedLastTakenDateValue> get copyWith => throw _privateConstructorUsedError;
}

/// @nodoc
abstract class $AutomaticallyRecordedLastTakenDateValueCopyWith<$Res> {
  factory $AutomaticallyRecordedLastTakenDateValueCopyWith(
          AutomaticallyRecordedLastTakenDateValue value, $Res Function(AutomaticallyRecordedLastTakenDateValue) then) =
      _$AutomaticallyRecordedLastTakenDateValueCopyWithImpl<$Res, AutomaticallyRecordedLastTakenDateValue>;
  @useResult
  $Res call(
      {@JsonKey(fromJson: TimestampConverter.timestampToDateTime, toJson: TimestampConverter.dateTimeToTimestamp) DateTime? beforeLastTakenDate,
      @JsonKey(fromJson: NonNullTimestampConverter.timestampToDateTime, toJson: NonNullTimestampConverter.dateTimeToTimestamp)
      DateTime afterLastTakenDate,
      int beforeLastTakenPillNumber,
      int afterLastTakenPillNumber});
}

/// @nodoc
class _$AutomaticallyRecordedLastTakenDateValueCopyWithImpl<$Res, $Val extends AutomaticallyRecordedLastTakenDateValue>
    implements $AutomaticallyRecordedLastTakenDateValueCopyWith<$Res> {
  _$AutomaticallyRecordedLastTakenDateValueCopyWithImpl(this._value, this._then);

  // ignore: unused_field
  final $Val _value;
  // ignore: unused_field
  final $Res Function($Val) _then;

  @pragma('vm:prefer-inline')
  @override
  $Res call({
    Object? beforeLastTakenDate = freezed,
    Object? afterLastTakenDate = null,
    Object? beforeLastTakenPillNumber = null,
    Object? afterLastTakenPillNumber = null,
  }) {
    return _then(_value.copyWith(
      beforeLastTakenDate: freezed == beforeLastTakenDate
          ? _value.beforeLastTakenDate
          :


 number of "real world" arrivals in this space-time-bin after handling the current arrival.
	 * Negative arrivals are equivalent to departures. Therefore a return value of 0 not necessarily means no
	 * no departures, but only that there are as many arrivals as departures (which still could be 0)
	 */
	public int handleDeparture(int time, double x, double y, int weight) {
		return this.carArrivals[getTimeBin(time)].adjustOrPutValue(this.hectareMapper.getKey(x, y), -weight, -weight);
	}

	/**
	 * Calculates for each space-time-bin the number of specimen based on the initial load received in the
	 * constructor and the departures and arrivals collected with {@linkplain #handleArrival(int, double, double, int)}
	 * and {@linkplain #handleDeparture(int, double, double, int)} and then generates a {@linkplain PenaltyCalculator}
	 * based on the result.
	 */
	@Override
	public PenaltyCalculator generatePenaltyCalculator() {
		TLongIntMap[] cars = new TLongIntMap[this.carArrivals.length];
		cars[0] = new TLongIntHashMap(this.initialLoad);
		for (int i = 1; i < this.carArrivals.length; i++) {
			cars[i] = new TLongIntHashMap(cars[i-1]);
			TLongIntIterator iter = this.carArrivals[i-1].iterator();
			while (iter.hasNext()) {
				iter.advance();
				cars[i].adjustOrPutValue(iter.key(), iter.value(), iter.value());
			}
		}

		return new PenaltyCalculator(cars, this.timeBinSize, this.hectareMapper);
	}

	/**
	 * sets all arrival bins to 0
	 */
	@Override
	public void reset() {
		for (int i = 0; i < this.carArrivals.length; i++) {
			this.carArrivals[i] = new TLongIntHashMap();
		}
	}

	private int getTimeBin(int time) {
		return TimeBinUtils.getTimeBinIndex(time, this.timeBinSize, this.numberOfTimeBins);
	}
}
package org.matsim.contrib.parking.parkingsearch.sim;

import java.util.Collection;
import java.util.LinkedList;

import org.matsim.core.config.Config;
import org.matsim.core.config.groups.NetworkConfigGroup;
import org.matsim.core.mobsim.framework.Mobsim;
import org.matsim.core.mobsim.qsim.AbstractQSimModule;
import org.matsim.core.mobsim.qsim.PopulationModule;
import org.matsim.core.mobsim.qsim.QSimModule;
import org.matsim.core.mobsim.qsim.QSimProvider;
import org.matsim.core.mobsim.qsim.components.QSimComponentsConfig;
import org.matsim.core.mobsim.qsim.components.StandardQSimComponentConfigurator;
import org.matsim.pt.config.TransitConfigGroup;

import com.google.inject.Provides;

public class ParkingSearchQSimModule extends com.google.inject.AbstractModule {
	@Override
	protected void configure() {
		bind(Mobsim.class).toProvider(QSimProvider.class);

	}

	@SuppressWarnings("static-method")
	@Provides
	Collection<AbstractQSimModule> provideQSimModules(TransitConfigGroup transitConfigGroup, NetworkConfigGroup networkConfigGroup, Config config) {
		Collection<AbstractQSimModule> modules = new LinkedList<>(QSimModule.getDefaultQSimModules());
		modules.removeIf(PopulationModule.class::isInstance);
		modules.add(new ParkingSearchPopulationModule());
		return modules;
	}

	@Provides
	QSimComponentsConfig provideQSimComponentsConfig(Config config) {
		QSimComponentsConfig components = new QSimComponentsConfig();
		new StandardQSimComponentConfigurator(config).configure(components);

		components.removeNamedComponent(PopulationModule.COMPONENT_NAME);
		components.addNamedComponent(ParkingSearchPopulationModule.COMPONENT_NAME);

		return components;
	}
}
/* *******************************************************


| --- | --- |
| 内核初始化器 | He 初始化 |
| 激活函数 | 如果是浅层则为 ReLU；如果是深层则为 Swish |
| 归一化 | 如果是浅层则为无；如果是深层则为批量归一化 |
| 正则化 | 提前停止；如果需要则使用权重衰减 |
| 优化器 | Nesterov 加速梯度或 AdamW |
| 学习率调度 | 性能调度或 1cycle |

如果网络是简单的密集层堆叠，则它可以自我归一化，您应该使用表 11-4 中的配置。

表 11-4. 自我归一化网络的 DNN 配置

| 超参数 | 默认值 |
| --- | --- |
| 内核初始化器 | LeCun 初始化 |
| 激活函数 | SELU |
| 归一化 | 无（自我归一化） |
| 正则化 | 如果需要则使用 Alpha dropout |
| 优化器 | Nesterov 加速梯度 |
| 学习率调度 | 性能调度或 1cycle |

不要忘记对输入特征进行归一化！您还应尝试重用预训练神经网络的部分，如果您可以找到一个解决类似问题的模型，或者如果您有大量未标记数据，则使用无监督预训练，或者如果您有大量类似任务的标记数据，则使用辅助任务的预训练。

虽然前面的指南应该涵盖了大多数情况，但这里有一些例外情况：

+   如果您需要一个稀疏模型，您可以使用ℓ[1]正则化（并在训练后选择性地将微小权重归零）。如果您需要一个更稀疏的模型，您可以使用 TensorFlow 模型优化工具包。这将破坏自我归一化，因此在这种情况下应使用默认配置。

+   如果您需要一个低延迟模型（执行闪电般快速预测的模型），您可能需要使用更少的层，使用快速激活函数（如 ReLU 或 leaky ReLU），并在训练后将批量归一化层折叠到前面的层中。拥有一个稀疏模型也会有所帮助。最后，您可能希望将浮点精度从 32 位减少到 16 位甚至 8 位（参见“将模型部署到移动设备或嵌入式设备”）。再次，查看 TF-MOT。

+   如果您正在构建一个风险敏感的应用程序，或者推断延迟在您的应用程序中并不是非常重要，您可以使用 MC dropout 来提高性能，并获得更可靠的概率估计，以及不确定性估计。

有了这些指导，您现在已经准备好训练非常深的网络了！我希望您现在相信，只使用方便的 Keras API 就可以走很长一段路。然而，可能会有一天，当


 (d2Left33 * rightTerm + dLeft3 * dRight3.transpose() +
                                                d2Right33 * leftTerm * Eigen::Matrix2d::Identity() + dRight3 * dLeft3.transpose());

            // project to nearest SPD matrix
            IglUtils::makePD(curHessian);

            Eigen::VectorXi& vInd = vInds[triI];
            vInd = triVInd;
            for(int vI = 0; vI < 3; vI++) {
                if(data.fixedVert.find(vInd[vI]) != data.fixedVert.end()) {
                    vInd[vI] = -1;
                }
            }
            //        }
        });
        for(int triI = 0; triI < data.F.rows(); triI++) {
            IglUtils::addBlockToMatrix(triHessians[triI], vInds[triI], 2, Hessian);
        }

        Eigen::VectorXi fixedVertInd;
        fixedVertInd.resize(data.fixedVert.size());
        int fVI = 0;
        for(const auto fixedVI : data.fixedVert) {
            fixedVertInd[fVI++] = fixedVI;
        }
        IglUtils::addDiagonalToMatrix(Eigen::VectorXd::Ones(data.fixedVert.size() * 2),
                                      fixedVertInd, 2, Hessian);
    }

    void SymDirichletEnergy::computeHessian(const TriMesh& data, Eigen::VectorXd* V,
                                            Eigen::VectorXi* I, Eigen::VectorXi* J, bool uniformWeight) const
    {
        const double normalizer_div = data.surfaceArea;

//        std::cout << "computing entry value..." << std::endl;
//        clock_t start = clock();
        std::vector<Eigen::Matrix<double, 6, 6>> triHessians(data.F.rows());
        std::vector<Eigen::VectorXi> vInds(data.F.rows());
        tbb::parallel_for(0, (int)data.F.rows(), 1, [&](int triI) {
//        for(int triI = 0; triI < data.F.rows(); triI++) {
            const Eigen::Vector3i& triVInd = data.F.row(triI);

            const Eigen::Vector2d& U1 = data.V.row(triVInd[0]);
            const Eigen::Vector2d& U2 = data.V.row(triVInd[1]);
            const Eigen::Vector2d& U3 = data.V.row(triVInd[2]);

            const Eigen::Vector2d U2m1 = U2 - U1;
            const Eigen::Vector2d U3m1 = U3 - U1;

            const double area_U = 0.5 * (U2m1[0] * U3m1[1] - U2m1[1] * U3m1[0]);
            const double areaRatio = data.triAreaSq[triI] / area_U / area_U / area_U;
            const double dAreaRatio_div_dArea_mult = 3.0 / 2.0 * areaRatio / area_U;

            const double w = (uniformWeight ? 1.0 : (data.triArea[triI] / normalizer_div));

            const double e0SqLen_div_dbAreaSq = data.e0SqLen_div_dbAreaSq[triI];
            const double e1SqLen_div_dbAreaSq = data.e1SqLen_div_dbAreaSq[triI];
            const double e0dote1_div_dbAreaSq = data.e0dote1_div_dbAreaSq[triI];

            // compute energy terms
            const double leftTerm = 1.0 + data.triAreaSq[triI] / area_U / area_U;
            const double


 uint64(0x0))
	var x137 uint64
	var x138 uint64
	x137, x138 = bits.Add64(x132, x129, uint64(sm2p256scalarUint1(x136)))
	var x139 uint64
	var x140 uint64
	x139, x140 = bits.Add64(x130, x127, uint64(sm2p256scalarUint1(x138)))
	x141 := (uint64(sm2p256scalarUint1(x140)) + x128)
	var x143 uint64
	_, x143 = bits.Add64(x115, x133, uint64(0x0))
	var x144 uint64
	var x145 uint64
	x144, x145 = bits.Add64(x117, x135, uint64(sm2p256scalarUint1(x143)))
	var x146 uint64
	var x147 uint64
	x146, x147 = bits.Add64(x119, x137, uint64(sm2p256scalarUint1(x145)))
	var x148 uint64
	var x149 uint64
	x148, x149 = bits.Add64(x121, x139, uint64(sm2p256scalarUint1(x147)))
	var x150 uint64
	var x151 uint64
	x150, x151 = bits.Add64(x123, x141, uint64(sm2p256scalarUint1(x149)))
	x152 := (uint64(sm2p256scalarUint1(x151)) + uint64(sm2p256scalarUint1(x124)))
	var x153 uint64
	var x154 uint64
	x154, x153 = bits.Mul64(x3, arg2[3])
	var x155 uint64
	var x156 uint64
	x156, x155 = bits.Mul64(x3, arg2[2])
	var x157 uint64
	var x158 uint64
	x158, x157 = bits.Mul64(x3, arg2[1])
	var x159 uint64
	var x160 uint64
	x160, x159 = bits.Mul64(x3, arg2[0])
	var x161 uint64
	var x162 uint64
	x161, x162 = bits.Add64(x160, x157, uint64(0x0))
	var x163 uint64
	var x164 uint64
	x163, x164 = bits.Add64(x158, x155, uint64(sm2p256scalarUint1(x162)))
	var x165 uint64
	var x166 uint64
	x165, x166 = bits.Add64(x156, x153, uint64(sm2p256scalarUint1(x164)))
	x167 := (uint64(sm2p256scalarUint1(x166)) + x154)
	var x168 uint64
	var x169 uint64
	x168, x169 = bits.Add64(x144, x159, uint64(0x0))
	var x170 uint64
	var x171 uint64
	x170, x171 = bits.Add64(x146, x161, uint64(sm2p256scalarUint1(x169)))
	var x172 uint64
	var x173 uint64
	x172, x173 = bits.Add64(x148, x163, uint64(sm2p256scalarUint1(x171)))
	var x174 uint64
	var x175 uint64
	x174, x175 = bits.Add64(x150, x165, uint64(sm2p256scalarUint1(x173)))
	var x176 uint64
	var x177 uint64
	x176, x177 = bits.Add64(x152, x167, uint64(sm2p256scalarUint1(x175)))
	var x178 uint64
	_, x178 = bits.Mul64(x168, 0x327f9e8872350975)
	var x180 uint64
	var x181 uint64
	x181, x180 = bits.Mul64(x178, 0xfffffffeffffffff)
	var x182 uint64
	var x183 uint64
	x183, x182 = bits.Mul64


: String, val readableName: String, val icon: Icon) {
    MODULE("d_language_module", "module", DLanguage.Icons.MODULE),
    CLASS("d_language_class", "class", DLanguage.Icons.NODE_CLASS),
    INTERFACE("d_language_interface", "interface", DLanguage.Icons.NODE_INTERFACE),
    STRUCT("d_language_struct", "struct", DLanguage.Icons.NODE_STRUCT),
    UNION("d_language_union", "union", DLanguage.Icons.NODE_UNION),
    ENUM("d_language_enum", "enum", DLanguage.Icons.NODE_ENUM)
}
package io.github.intellij.dlanguage

import com.intellij.lang.ASTNode
import com.intellij.lang.ParserDefinition
import com.intellij.lexer.Lexer
import com.intellij.openapi.project.Project
import com.intellij.psi.FileViewProvider
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiFile
import com.intellij.psi.TokenType
import com.intellij.psi.tree.TokenSet
import com.intellij.psi.tree.TokenSet.create
import com.intellij.psi.tree.TokenSet.orSet
import io.github.intellij.dlanguage.lexer.DlangLexer
import io.github.intellij.dlanguage.parser.ParserWrapper
import io.github.intellij.dlanguage.psi.DTokenSets.STRING_LITERALS
import io.github.intellij.dlanguage.psi.DlangPsiFileImpl
import io.github.intellij.dlanguage.psi.DlangTypes
import io.github.intellij.dlanguage.stubs.types.DFileStubElementType

class DLangParserDefinition : ParserDefinition {
    val WHITE_SPACES: TokenSet = create(TokenType.WHITE_SPACE)
    val REGULAR_COMMENTS: TokenSet = create(DlangTypes.LINE_COMMENT, DlangTypes.BLOCK_COMMENT, DlangTypes.NESTING_BLOCK_COMMENT)
    val DOC_COMMENTS: TokenSet = create(DlangTypes.LINE_DOC, DlangTypes.BLOCK_DOC, DlangTypes.NESTING_BLOCK_DOC)
    val COMMENTS: TokenSet = orSet(REGULAR_COMMENTS, DOC_COMMENTS)

    override fun createParser(project: Project?): ParserWrapper = ParserWrapper()

    override fun createFile(viewProvider: FileViewProvider): PsiFile = DlangPsiFileImpl(viewProvider)

    override fun spaceExistenceTypeBetweenTokens(left: ASTNode?, right: ASTNode?): ParserDefinition.SpaceRequirements = ParserDefinition.SpaceRequirements.MAY

    override fun getStringLiteralElements(): TokenSet = STRING_LITERALS

    override fun getFileNodeType(): DFileStubElementType = DFileStubElementType.INSTANCE

    override fun getWhitespaceTokens(): TokenSet = WHITE_SPACES

    override fun createLexer(project: Project?): Lexer = DlangLexer()

    override fun createElement(node: ASTNode?): PsiElement = DlangTypes.Factory.createElement(node)

    override fun getCommentTokens(): TokenSet = COMMENTS
}

package io.github.intellij.dlanguage.annotator

import com.intellij.lang.annotation.AnnotationHolder
import com.intellij.lang.annotation.HighlightSeverity
import io.github.intellij.dlanguage.DlangBundle
import io.github.intellij.dlanguage.utils.DPsiLiteralUtil
import io.github.intellij.dlanguage.utils.LiteralExpression

fun checkLiteral(expressionElement: LiteralExpression, holder: AnnotationHolder) {
    if (expressionElement.integeR_LITERAL != null) {
        val element = expressionElement.integeR_LITERAL!!
        val text = element.text
        if (DPsiLiteralUtil.isHexadecimal(text) && !text.substring(2).contains("[0-9a-fA-F]".toRegex()))
            holder.newAnnotation(HighlightSeverity.ERROR, DlangBundle.message("literal.hexadecimal.no.digits")).range(element).create()
        else if (DPsiLiteralUtil


);
		connect(matchManagment_, SIGNAL(settingsChanged(MatchSettings &)),
			cvmatchleft.get(),
			SLOT(updateSettings(MatchSettings &)));
		matchscene_ptr->addMatch(std::move(cvmatchleft));

		auto cvmatchright = util::make_unique<qtutil::CVVPointMatch>(
		    rightinvisibleKeys.at(match.queryIdx),
		    rightKeys.at((usetrainIdx ? match.trainIdx : match.imgIdx)),
		    match, false);
		connect(matchManagment_, SIGNAL(settingsChanged(MatchSettings &)),
			cvmatchright.get(),
			SLOT(updateSettings(MatchSettings &)));
		matchscene_ptr->addMatch(std::move(cvmatchright));
	}
	matchManagment_->updateAll();
}
}
}

#include <QHBoxLayout>

#include "../qtutil/accordion.hpp"
#include "../qtutil/matchview/matchscene.hpp"
#include "../qtutil/matchview/cvvkeypoint.hpp"
#include "../qtutil/matchview/cvvmatch.hpp"
#include "../qtutil/matchview/showinrawviewwidget.hpp"
#include "../util/util.hpp"

#include "translationsmatchview.hpp"

namespace cvv
{
namespace view
{

TranslationMatchView::TranslationMatchView(
    std::vector<cv::KeyPoint> leftKeyPoints,
    std::vector<cv::KeyPoint> rightKeyPoints, std::vector<cv::DMatch> matches,
    cv::Mat leftIm, cv::Mat rightIm, bool usetrainIdx, QWidget *parent)
    : MatchView( parent )
{
	std::vector<cv::KeyPoint> allkeypoints;
	for(auto key:rightKeyPoints)
	{
		allkeypoints.push_back(key);
	}

	for(auto key:leftKeyPoints){
		allkeypoints.push_back(key);
	}

	auto layout = util::make_unique<QHBoxLayout>();
	auto accor = util::make_unique<qtutil::Accordion>();
	auto matchscene =
	    util::make_unique<qtutil::MatchScene>(leftIm, rightIm);
	auto matchmnt = util::make_unique<qtutil::MatchManagement>(matches);
	auto keyPointmnt = util::make_unique<qtutil::KeyPointManagement>(allkeypoints);

	qtutil::MatchScene *matchscene_ptr = matchscene.get();
	int updateAreaDelay=std::min(std::max(matches.size(),std::max(leftKeyPoints.size(),rightKeyPoints.size()))/(std::size_t)10,(std::size_t)50);
	matchscene_ptr->getLeftImage().setUpdateAreaDelay(updateAreaDelay);
	matchscene_ptr->getRightImage().setUpdateAreaDelay(updateAreaDelay);

	matchManagment_ = matchmnt.get();
	keyManagment_ = keyPointmnt.get();

	connect(&matchscene_ptr->getLeftImage(),SIGNAL(updateMouseHover(QPointF,QString,bool)),
		this,SLOT(updateMousHoverOver(QPointF,QString,bool)));
	connect(&matchscene_ptr->getRightImage(),SIGNAL(updateMouseHover(QPointF,QString,bool)),
		this,SLOT(updateMousHoverOver(QPointF,QString,bool)));

	accor->setMinimumWidth(350);
	accor->setMaximumWidth(350);

	accor->insert("Match Settings", std::move(matchmnt));
	accor->insert("KeyPoint Settings", std::move(keyPointmnt));
	accor->insert("Show selection in rawview window",
              util::make_unique<qtutil::ShowInRawView>(leftKeyPoints,
								 rightKeyPoints,
								 matches,
								 matchManagment_,
                                 keyManagment_));
	accor->insert("Sync Zoom ",
              matchscene_ptr->getSyncZoomWidget());
	accor->insert("Left Image ",
              matchscene_ptr->getLeftMatInfoWidget());
	accor-


ar thisDelay = debounceNextCall || delay;
        var thisDebounce = debounceNextCall || debounce;
        debounceNextCall = null;
        diff = currCall - (thisDebounce ? lastCall : lastExec) - thisDelay;

        clearTimeout(timer);

        // Here we should make sure that: the `exec` SHOULD NOT be called later
        // than a new call of `cb`, that is, preserving the command order. Consider
        // calculating "scale rate" when roaming as an example. When a call of `cb`
        // happens, either the `exec` is called dierectly, or the call is delayed.
        // But the delayed call should never be later than next call of `cb`. Under
        // this assurance, we can simply update view state each time `dispatchAction`
        // triggered by user roaming, but not need to add extra code to avoid the
        // state being "rolled-back".
        if (thisDebounce) {
            timer = setTimeout(exec, thisDelay);
        }
        else {
            if (diff >= 0) {
                exec();
            }
            else {
                timer = setTimeout(exec, -diff);
            }
        }

        lastCall = currCall;
    };

    /**
     * Clear throttle.
     * @public
     */
    cb.clear = function () {
        if (timer) {
            clearTimeout(timer);
            timer = null;
        }
    };

    /**
     * Enable debounce once.
     */
    cb.debounceNextCall = function (debounceDelay) {
        debounceNextCall = debounceDelay;
    };

    return cb;
}

/**
 * Create throttle method or update throttle rate.
 *
 * @example
 * ComponentView.prototype.render = function () {
 *     ...
 *     throttle.createOrUpdate(
 *         this,
 *         '_dispatchAction',
 *         this.model.get('throttle'),
 *         'fixRate'
 *     );
 * };
 * ComponentView.prototype.remove = function () {
 *     throttle.clear(this, '_dispatchAction');
 * };
 * ComponentView.prototype.dispose = function () {
 *     throttle.clear(this, '_dispatchAction');
 * };
 *
 * @public
 * @param {Object} obj
 * @param {string} fnAttr
 * @param {number} [rate]
 * @param {string} [throttleType='fixRate'] 'fixRate' or 'debounce'
 * @return {Function} throttled function.
 */
function createOrUpdate(obj, fnAttr, rate, throttleType) {
    var fn = obj[fnAttr];

    if (!fn) {
        return;
    }

    var originFn = fn[ORIGIN_METHOD] || fn;
    var lastThrottleType = fn[THROTTLE_TYPE];
    var lastRate = fn[RATE];

    if (lastRate !== rate || lastThrottleType !== throttleType) {
        if (rate == null || !throttleType) {
            return (obj[fnAttr] = originFn);
        }

        fn = obj[fnAttr] = throttle(
            originFn, rate, throttleType === 'debounce'
        );
        fn[ORIGIN_METHOD] = originFn;
        fn[THROTTLE_TYPE] = throttleType;
        fn[RATE] = rate;
    }

    return fn;
}

/**
 * Clear throttle. Example see throttle.createOrUpdate.
 *
 * @public
 * @param {Object} obj
 * @param {string} fnAttr
 */
function clear(obj, fnAttr) {
    var fn = obj[fnAttr];
    if (fn && fn[ORIGIN_METHOD]) {
        obj[fnAttr] = fn[ORIGIN_METHOD];
    }
}

/*
* 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-


 Latest Chapters
        fun getIndex(name: String): Element { // Bruh, has to do this because sometimes it varies between 14 and 15 elements
            return info[names.indexOf(name)]
        }

        val name = document.selectFirst("div.block-title")?.text() ?: return null

        val data: ArrayList<ChapterData> = ArrayList()
        val panels = document.select("div.panel")
        for (p in panels) {
            var pName = p.select("> div.panel-heading > h4.panel-title > a").text()
            pName = if (pName == "Chapters") "" else "$pName • "

            val chapterHeaders =
                p.select("> div.panel-collapse > div.panel-body > div.tab-content > div.tab-pane > ul.chapter-chs > li > a")
            for (c in chapterHeaders) {
                val cName = c.text()
                val cUrl = c?.attr("href") ?: continue
                var rName = cName
                    .replace("CH ([0-9]*)".toRegex(), "Chapter $1")
                    .replace("CH ", "")

                rName = when (rName) {
                    "Pr" -> "Prologue"
                    "Ep" -> "Epilogue"
                    else -> rName
                }

                data.add(ChapterData(pName + rName, fixUrl(cUrl), null, null))
            }
        }

        return newStreamResponse(url = url, name = name, data = data) {
            posterUrl = fixUrlNull(document.selectFirst("div.novel-cover > a > img")?.attr("src"))
            setStatus(getIndex("Status").text())
            synopsis =
                getIndex("Description").select("> p").joinToString(separator = "\n\n") { it.text() }
            rating = (getIndex("Rating").text().toFloat() * 100).toInt()
            author = getIndex("Author(s)").selectFirst("> ul > li")?.text()
            if (author == "N/A") author = null
            tags = getIndex("Genre").select("ul > li > a").map { it.text() }
            views = getIndex("Total Views").text().replace(",", "").replace(".", "").toInt()
        }
    }
}package com.lagradost.quicknovel.ui.search

import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.FrameLayout
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.ListAdapter
import androidx.recyclerview.widget.RecyclerView
import com.lagradost.quicknovel.SearchResponse
import com.lagradost.quicknovel.databinding.SearchResultGridBinding
import com.lagradost.quicknovel.util.Apis
import com.lagradost.quicknovel.util.UIHelper.setImage
import com.lagradost.quicknovel.util.toPx
import com.lagradost.quicknovel.widget.AutofitRecyclerView
import kotlin.math.roundToInt

class SearchAdapter2(
    private val viewModel: SearchViewModel,
    private val resView: AutofitRecyclerView,
) :
    ListAdapter<SearchResponse, SearchAdapter2.SearchAdapter2Holder>(DiffCallback()) {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SearchAdapter2Holder {
        val binding =
            SearchResultGridBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return SearchAdapter2Holder(binding, resView, viewModel)
    }

    override fun onBindViewHolder(holder: SearchAdapter2Holder, position: Int) {
        val currentItem = getItem(position)
        holder.bind(currentItem)
    }

    class SearchAdapter2Holder(
        private val binding: SearchResultGridBinding,
        private val resView: AutofitRecyclerView,
        private val viewModel: SearchViewModel
    ) :
        RecyclerView.ViewHolder(binding.root) {

        fun bind


ist2.js"></script>-->
<script language="JavaScript">

//	ALSW	10	アローシャワー
//	CNCT	10	集中力向上
//	DBLS	10	ダブルストレイフィング
//	OWLE	10	ふくろうの目
//	VLTE	10	ワシの目
//
//	ANKL	5 	アンクルスネア
//	BLST	5 	ブラストマイン
//	BLTZ	5 	ブリッツビート
//	BSTB	10	ビーストベイン
//	CLYM	5 	クレイモアートラップ
//	DTCT	4 	ディテクティング
//	FALC	1 	ファルコンマスタリー
//	FLSH	5 	フラッシャー
//	FREZ	5 	フリージングトラップ
//	LNDM	5 	ランドマイン
//	REMV	1 	リムーブトラップ
//	SKID	5 	スキッドトラップ
//	SKWV	5 	ショックウェーブトラップ
//	SNDM	5 	サンドマン
//	SPRN	5 	スプリングトラップ
//	STLC	10	スチールクロウ
//	TALK	1 	トーキーボックス
//
//	TRST	10	トゥルーサイト
//	FLAS	5 	ファルコンアサルト
//	SHSH	5 	シャープシューティング
//	WDWK	10	ウインドウォーク
//
//	RGRM	10	レンジャーメイン
//	CAMO	5	カモフラージュ
//	AIMB	10	エイムドボルト
//	ARST	10	アローストーム
//	FRBZ	5	フィアーブリーズ
//	RTRP	5	トラップ研究
//	MGNT	1	マゼンタトラップ
//	COBA	1	コバルトトラップ
//	VERD	1	ヴェルデュールトラップ
//	MAIZ	1	メイズトラップ
//	CBOM	5	クラスターボム
//	DETN	1	デトネイター
//	FRIN	5	ファイアリングトラップ
//	ICBN	5	アイスバウンドトラップ
//	ELEC	5	エレクトリックショッカー
//	WGMS	1	ウォグマスタリー
//	WGBT	5	ウォグバイト
//	TOWG	10	トゥースオブウォグ
//	WGST	5	ウォグストライク
//	KEEN	5	鋭敏な嗅覚
//	WGRD	3	ウォグライダー
//	WGDS	1	ウォグダッシュ

var ALSW_P = CNCT_P = DBLS_P = OWLE_P
	= VLTE_P
	= ANKL_P = BLST_P = BLTZ_P = BSTB_P
	= CLYM_P = DTCT_P = FALC_P = FLSH_P
	= FREZ_P = LNDM_P = REMV_P = SKID_P
	= SKWV_P = SNDM_P = SPRN_P = STLC_P
	= TALK_P
	= TRST_P = FLAS_P = SHSH_P = WDWK_P
	= RGRM_P = CAMO_P = AIMB_P = ARST_P
	= FRBZ_P = RTRP_P = MGNT_P = COBA_P
	= VERD_P = MAIZ_P = CBOM_P = DETN_P
	= FRIN_P = ICBN_P = ELEC_P = WGMS_P
	= WGBT_P = TOWG_P = WGST_P = KEEN_P
	= WGRD_P = WGDS_P
	= 0;

var use1 = use2 = use3 = 0;
var JCHF_P = 50;
var JCHT_P = 70;
var ver = "10";

var ALSW_M = 10;
var CNCT_M = 10;
var DBLS_M = 10;
var OWLE_M = 10;
var VLTE_M = 10;

var ANKL_M = 5 ;
var BLST_M = 5 ;
var BLTZ_M = 5 ;
var BSTB_M = 10;
var CLYM_M = 5 ;
var DTCT_M = 4 ;
var FALC_M = 1 ;
var FLSH_M = 5 ;
var FREZ_M = 5 ;
var LNDM_M = 5 ;
var REMV_M = 1 ;
var SKID


local LINA_BOT_STATE_IDLE					= 0
local LINA_BOT_STATE_TANGO					= 1
local LINA_BOT_STATE_BLADE					= 2

-----------------------------------------------------------------------------------------------------

if CRegenLinaBot == nil then
	CRegenLinaBot = class({})
end

function CRegenLinaBot:constructor( me )
	self.me = me

	self.hAbilityLagunaBlade = self.me:FindAbilityByName( "lina_laguna_blade" )

	self.nBotState = LINA_BOT_STATE_IDLE
end

function CRegenLinaBot:ChangeBotState( nNewState )
	self.nBotState = nNewState
end

function CRegenLinaBot:BotThink()
	if not IsServer() then
		return
	end

	if not self.me:IsAlive() then
		return
	end

	if GameRules:IsGamePaused() then
		return
	end

	if self.nBotState == LINA_BOT_STATE_IDLE then
        if self.vHome == nil then
            self.vHome = self.me:GetAbsOrigin()
        end

        if ( self.vHome - self.me:GetAbsOrigin() ):Length2D() > 150 then
            ExecuteOrderFromTable( {
                UnitIndex = self.me:entindex(),
                OrderType = DOTA_UNIT_ORDER_MOVE_TO_POSITION,
                Position = self.vHome,
                Queue = false,
            } )
            return
        end

        if self.hSingleTango == nil then
            self.hSingleTango = self.me:FindItemInInventory( "item_tango_single" )
            if self.hSingleTango and self.hSingleTango:IsFullyCastable() and self.me:GetHealthPercent() < 100 then


Parser(_httpContextAccessor.HttpContext, modelBoundProvider);
            IAsyncEnumerable<Model.ManyColumns> manyColumns = parser.ExecuteReader<Model.ManyColumns>();
            return parser.OData(manyColumns);
        }
        [HttpGet("{id}")]
        public ODataResult<Model.ManyColumns> Get(int id)
        {
            var parser = new OeAspQueryParser(_httpContextAccessor.HttpContext);
            IAsyncEnumerable<Model.ManyColumns> manyColumns = parser.ExecuteReader<Model.ManyColumns>();
            return parser.OData(manyColumns);
        }
        [HttpPatch]
        public void Patch(OeDataContext dataContext, IDictionary<String, Object> manyColumnsProperties)
        {
            dataContext.Update(manyColumnsProperties);
        }
        [HttpPost]
        public void Post(OeDataContext dataContext, Model.ManyColumns manyColumns)
        {
            dataContext.Update(manyColumns);
        }
    }
}


ReportRequest_descriptor;
  }

  @java.lang.Override
  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
      internalGetFieldAccessorTable() {
    return com.google.ads.admanager.v1.ReportServiceProto
        .internal_static_google_ads_admanager_v1_UpdateReportRequest_fieldAccessorTable
        .ensureFieldAccessorsInitialized(
            com.google.ads.admanager.v1.UpdateReportRequest.class,
            com.google.ads.admanager.v1.UpdateReportRequest.Builder.class);
  }

  private int bitField0_;
  public static final int REPORT_FIELD_NUMBER = 1;
  private com.google.ads.admanager.v1.Report report_;

  /**
   *
   *
   *

   * Required. The `Report` to update.
   *

   *
   * .google.ads.admanager.v1.Report report = 1 [(.google.api.field_behavior) = REQUIRED];
   *
   *
   * @return Whether the report field is set.
   */
  @java.lang.Override
  public boolean hasReport() {
    return ((bitField0_ & 0x00000001) != 0);
  }

  /**
   *
   *
   *

   * Required. The `Report` to update.
   *

   *
   * .google.ads.admanager.v1.Report report = 1 [(.google.api.field_behavior) = REQUIRED];
   *
   *
   * @return The report.
   */
  @java.lang.Override
  public com.google.ads.admanager.v1.Report getReport() {
    return report_ == null ? com.google.ads.admanager.v1.Report.getDefaultInstance() : report_;
  }

  /**
   *
   *
   *

   * Required. The `Report` to update.
   *

   *
   * .google.ads.admanager.v1.Report report = 1 [(.google.api.field_behavior) = REQUIRED];
   *
   */
  @java.lang.Override
  public com.google.ads.admanager.v1.ReportOrBuilder getReportOrBuilder() {
    return report_ == null ? com.google.ads.admanager.v1.Report.getDefaultInstance() : report_;
  }

  public static final int UPDATE_MASK_FIELD_NUMBER = 2;
  private com.google.protobuf.FieldMask updateMask_;

  /**
   *
   *
   *

   * Required. The list of fields to update.
   *

   *
   * .google.protobuf.FieldMask update_mask = 2 [(.google.api.field_behavior) = REQUIRED];
   *
   *
   * @return Whether the updateMask field is set.
   */
  @java.lang.Override
  public boolean hasUpdateMask() {
    return ((bitField0_ & 0x00000002) != 0);
  }

  /**
   *
   *
   *

   * Required. The list of fields to update.
   *

   *
   * .google.protobuf.FieldMask update_mask = 2 [(.google.api.field_behavior) = REQUIRED];
   *
   *
   * @return The updateMask.
   */
  @java.lang.Override
  public com.google.protobuf.FieldMask getUpdateMask() {
    return updateMask_ == null ? com.google.protobuf.FieldMask.getDefaultInstance() : updateMask_;
  }

  /**
   *
   *
   *

   * Required. The list of fields to update.
   *

   *
   * .google.protobuf.FieldMask update_mask = 2 [(.google.api.field_behavior) = REQUIRED];
   *
   */
  @java.lang.Override
  public com.google.protobuf.FieldMaskOrBuilder getUpdateMaskOrBuilder() {
    return updateMask_ == null ? com.google.protobuf.FieldMask.getDefaultInstance() : updateMask_;
  }

  private b


// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using UnityEngine;

/// <summary>
/// Whenever this script is enabled, the spatial mesh observer is started. Whenever this script is disabled,
/// the mesh observer is stopped.
/// </summary>
public class SpatialMeshObserverAutoStater : MonoBehaviour
{
    private bool _quitting = false;

    #region Serialized Fields
    [SerializeField]
    [Tooltip("Should this behaviour stop the mesh observer when disabled.")]
    private bool autoStopOnDisable = false;

    /// <summary>
    /// Should this behaviour stop the mesh observer when disabled.
    /// </summary>
    public bool AutoStopOnDisable
    {
        get => autoStopOnDisable;
        set => autoStopOnDisable = value;
    }

    [SerializeField]
    [Tooltip("The number seconds after which to stop the spatial mesh observer after it was started by this script. Set to a negative or zero value to disable auto stops.")]
    private float autoStopAfterStart = 15.0f;

    /// <summary>
    /// The number seconds after which to stop the spatial mesh observer after it was started by this script. Set to a negative value to disable auto stops.
    /// </summary>
    public float AutoStopAfterStart
    {
        get => autoStopAfterStart;
        set => autoStopAfterStart = value;
    }

    [SerializeField]
    [Tooltip("If true, the mesh renderers will use the 'visible' materia. If false, the mesh renders will use the 'occlusion' material.")]
    private bool meshVisible = false;

    /// <summary>
    /// If


ne fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianOf(
    skipNaN: Boolean = skipNaNDefault,
    crossinline expression: RowExpression<T, R>,
): DataFrame<T> = Aggregators.medianCommon<R>(skipNaN).aggregateOf(this, expression)

public inline fun <T, reified R : Comparable<R & Any>?> PivotGroupBy<T>.medianBy(
    skipNaN: Boolean = skipNaNDefault,
    crossinline rowExpression: RowExpression<T, R>,
): ReducedPivotGroupBy<T> = reduce { medianByOrNull(skipNaN, rowExpression) }

@Deprecated(DEPRECATED_ACCESS_API)
@AccessApiOverload
public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
    column: ColumnReference<C>,
    skipNaN: Boolean = skipNaNDefault,
): ReducedPivotGroupBy<T> = reduce { medianByOrNull(column, skipNaN) }

public fun <T> PivotGroupBy<T>.medianBy(column: String, skipNaN: Boolean = skipNaNDefault): ReducedPivotGroupBy<T> =
    medianBy(column.toColumnAccessor().cast<Comparable<Any>?>(), skipNaN)

@Deprecated(DEPRECATED_ACCESS_API)
@AccessApiOverload
public inline fun <T, reified C : Comparable<C & Any>?> PivotGroupBy<T>.medianBy(
    column: KProperty<C>,
    skipNaN: Boolean = skipNaNDefault,
): ReducedPivotGroupBy<T> = medianBy(column.toColumnAccessor(), skipNaN)

// endregion
package org.jetbrains.kotlinx.dataframe.api

import org.jetbrains.kotlinx.dataframe.AnyColumnReference
import org.jetbrains.kotlinx.dataframe.ColumnsSelector
import org.jetbrains.kotlinx.dataframe.DataColumn
import org.jetbrains.kotlinx.dataframe.DataFrame
import org.jetbrains.kotlinx.dataframe.DataRow
import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
import org.jetbrains.kotlinx.dataframe.annotations.Refine
import org.jetbrains.kotlinx.dataframe.columns.ColumnGroup
import org.jetbrains.kotlinx.dataframe.columns.ColumnPath
import org.jetbrains.kotlinx.dataframe.columns.ColumnReference
import org.jetbrains.kotlinx.dataframe.columns.ColumnSet
import org.jetbrains.kotlinx.dataframe.columns.SingleColumn
import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
import org.jetbrains.kotlinx.dataframe.documentation.DslGrammarTemplateColumnsSelectionDsl.DslGrammarTemplate
import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources
import org.jetbrains.kotlinx.dataframe.documentation.Indent
import org.jetbrains.kotlinx.dataframe.documentation.LineBreak
import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
import org.jetbrains.kotlinx.dataframe.impl.columns.changePath
import org.jetbrains.kotlinx.dataframe.impl.columns.createColumnSet
import org.jetbrains.kotlinx.dataframe.util.DEPRECATED_ACCESS_API
import kotlin.reflect.KProperty

// region DataFrame

/**
 * ## The Select Operation
 *
 * Returns a new [DataFrame] with only the columns selected by [columns\].
 *
 * @include [SelectingColumns.ColumnGroupsAndNestedColumnsMention]
 *
 * See [Selecting Columns][SelectSelectingOptions].
 *
 * For more information: {@include [DocumentationUrls.Select]}


e",
"assets/assets/textures/square-outline.png": "b905d896d71bc85b43df499e7689d3ae",
"assets/assets/textures/MaryOculus.webm.nfo": "6033b42667e392be12600265c9e641e5",
"assets/assets/textures/kandao3.jpg": "26411563b5165e1d5fd0416466091667",
"assets/assets/textures/colors.png": "d7f400f404eec84540a93770785ae2d3",
"assets/assets/textures/envmap.png": "4a3d4f25652c670e32663464720108c3",
"assets/assets/textures/patterns/circuit_pattern.png": "28b98bbb36ff23e53db769b04875c9ea",
"assets/assets/textures/patterns/bright_squares256.png": "c007be9453123b75ca0fdf66a0f67671",
"assets/assets/textures/patterns/readme.txt": "c31a1f446cabe388e79e639786b1b1ea",
"assets/assets/textures/uv_grid_opengl.jpg": "ea0adfcb01cfcb26fe36ac0005606444",
"assets/assets/textures/golfball.jpg": "a84bbaa7e0765def26c0c6f7f8272bd9",
"assets/assets/textures/brick_roughness.jpg": "5f1e9e3fa70ee879bef174b8da9220ad",
"assets/assets/textures/hardwood2_diffuse.jpg": "94bed574871efc2888038b57b23805d1",
"assets/assets/textures/cube/Park2/negz.jpg": "101ece5be7592bfb4249a79e1968d3b6",
"assets/assets/textures/cube/Park2/negx.jpg": "6b2f292c33585296de8f4e638986bb79",
"assets/assets/textures/cube/Park2/negy.jpg": "9ed17cd7644cbc03321d4179aa06090d",
"assets/assets/textures/cube/Park2/readme.txt": "aaed0013d845535269df03a1d6ade4a9",
"assets/assets/textures/cube/Park2/posy.jpg": "01f7d2408087e4fc1fc03966616d35ef",
"assets/assets/textures/cube/Park2/posx.jpg": "d7f98688348b7540277ea8c6493f12a6",
"assets/assets/textures/cube/Park2/posz.jpg": "6579ac45179c999a22ca04f88c033e93",
"assets/assets/textures/cube/pisa/nx.png": "e94f696327b045cb939f494cc0a0d85a",
"assets/assets/textures/cube/pisa/ny.png": "70a8aa8f8b929d03fd2c2bbe7caabe8c",
"assets/assets/textures/cube/pisa/nz.png": "6af7bd6f734e12f2ccbb0c16d57a9795",
"assets/assets/textures/cube/pisa/pz.png": "47a01aa16f98a1d30e7c6a1c4734db33",
"assets/assets/textures/cube/pisa/px.png": "9210e854072e619e7a98b8a015e2eab7",
"assets/assets/textures/cube/pisa/py.png": "53f2fd65a58e8e993c57c9b8de962292",
"assets/assets/textures/crate_color8.tga": "07


 '10': 'text'},
    const {'1': 'duration', '3': 2, '4': 1, '5': 5, '10': 'duration'},
    const {'1': 'show', '3': 3, '4': 1, '5': 8, '10': 'show'},
    const {
      '1': 'button',
      '3': 4,
      '4': 1,
      '5': 11,
      '6': '.bilibili.community.service.dm.v1.Button',
      '10': 'button'
    },
  ],
};

/// Descriptor for `Toast`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List toastDescriptor = $convert.base64Decode(
    'CgVUb2FzdBISCgR0ZXh0GAEgASgJUgR0ZXh0EhoKCGR1cmF0aW9uGAIgASgFUghkdXJhdGlvbhISCgRzaG93GAMgASgIUgRzaG93EkAKBmJ1dHRvbhgEIAEoCzIoLmJpbGliaWxpLmNvbW11bml0eS5zZXJ2aWNlLmRtLnYxLkJ1dHRvblIGYnV0dG9u');
@$core.Deprecated('Use toastButtonV2Descriptor instead')
const ToastButtonV2$json = const {
  '1': 'ToastButtonV2',
  '2': const [
    const {'1': 'text', '3': 1, '4': 1, '5': 9, '10': 'text'},
    const {'1': 'action', '3': 2, '4': 1, '5': 5, '10': 'action'},
  ],
};

/// Descriptor for `ToastButtonV2`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List toastButtonV2Descriptor = $convert.base64Decode(
    'Cg1Ub2FzdEJ1dHRvblYyEhIKBHRleHQYASABKAlSBHRleHQSFgoGYWN0aW9uGAIgASgFUgZhY3Rpb24=');
@$core.Deprecated('Use toastV2Descriptor instead')
const ToastV2$json = const {
  '1': 'ToastV2',
  '2': const [
    const {'1': 'text', '3': 1, '4': 1, '5': 9, '10': 'text'},
    const {'1': 'duration', '3': 2, '4': 1, '5': 5, '10': 'duration'},
    const {
      '1': 'toast_button_v2',
      '3': 3,
      '4': 1,
      '5': 11,
      '6': '.bilibili.community.service.dm.v1.ToastButtonV2',
      '10': 'toastButtonV2'
    },
  ],
};

/// Descriptor for `ToastV2`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List toastV2Descriptor = $convert.base64Decode(
    'CgdUb2FzdFYyEhIKBHRleHQYASABKAlSBHRleHQSGgoIZHVyYXRpb24YAiABKAVSCGR1cmF0aW9uElcKD3RvYXN0X2J1dHRvbl92MhgDIAEoCzIvLmJpbGliaWxpLmNvbW11bml0eS5zZXJ2aWNlLmRtLnYxLlRvYXN0QnV0dG9uVjJSDXRvYXN0QnV0dG9uVjI=');
@$core.Deprecated('Use userInfoDescriptor instead')
const UserInfo$json = const {
  '1':


/* Generated by RuntimeBrowser
   Image: /System/Library/PrivateFrameworks/CalendarDaemon.framework/CalendarDaemon
 */

@interface CADNotificationMonitorOperationGroup : CADOperationGroup <CADNotificationMonitorInterface>

+ (bool)requiresEventAccess;
+ (bool)requiresEventOrReminderAccess;
+ (bool)requiresReminderAccess;
+ (id)whitelistedBundles;

- (void)CADCalendar:(struct { int x1; int x2; })arg1 setAlertedWithError:(id /* block */)arg2;
- (void)CADCalendarSetClearedFromNotificationCenter:(struct { int x1; int x2; })arg1 error:(id /* block */)arg2;
- (void)CADDatabaseGetEventNotificationItems:(id /* block */)arg1;
- (void)CADDatabaseGetInboxRepliedSectionItems:(id /* block */)arg1;
- (void)CADDatabaseGetInviteReplyNotifications:(id /* block */)arg1;
- (void)CADDatabaseGetReminderNotificationItems:(id /* block */)arg1;
- (void)CADDatabaseGetResourceChanges:(id /* block */)arg1;
- (void)CADDatabaseGetSharedCalendarInvitationsWithReply:(id /* block */)arg1;
- (void)CADEvent:(struct { int x1; int x2; })arg1 setAlertedWithError:(id /* block */)arg2;
- (void)CADEventSetInvitationStatus:(int)arg1 forEvent:(struct { int x1; int x2; })arg2 error:(id /* block */)arg3;
- (void)CADInviteReplyNotification:(struct { int x1; int x2; })arg1 setAlertedWithError:(id /* block */)arg2;
- (void)CADResourceChange:(struct { int x1; int x2; })arg1 setAlertedWithError:(id /* block */)arg2;

@end


\x00');
emit_start(_ZTV20btCollisionAlgorithm)
emit_32(0);
emit_32(_ZTI20btCollisionAlgorithm);
emit_32(_ZN20btCollisionAlgorithmD1Ev__index__);
emit_32(_ZN20btCollisionAlgorithmD0Ev__index__);
emit_32(__cxa_pure_virtual__index__);
emit_32(__cxa_pure_virtual__index__);
emit_32(__cxa_pure_virtual__index__);
emit_start(_ZTI20btCollisionAlgorithm)
emit_32(_ZTVN10__cxxabiv117__class_type_infoE+8);
emit_32(_ZTS20btCollisionAlgorithm);
emit_start(_ZTS20btCollisionAlgorithm)
emit_string('20btCollisionAlgorithm\x00');
emit_start(_ZTIN6btDbvt8ICollideE)
emit_32(_ZTVN10__cxxabiv117__class_type_infoE+8);
emit_32(_ZTSN6btDbvt8ICollideE);
emit_start(_ZTSN6btDbvt8ICollideE)
emit_string('N6btDbvt8ICollideE\x00');
emit_start(_2E_str1118)
emit_string('../../../../src/BulletCollision/BroadphaseCollision/btDbvt.cpp\x00');
emit_start(_2E_str22)
emit_string('n==p->childs[i]\x00');
emit_start(_ZTV18btDbvtTreeCollider)
emit_32(0);
emit_32(_ZTI18btDbvtTreeCollider);
emit_32(_ZN18btDbvtTreeColliderD1Ev__index__);
emit_32(_ZN18btDbvtTreeColliderD0Ev__index__);
emit_32(_ZN18btDbvtTreeCollider7ProcessEPK10btDbvtNodeS2___index__);
emit_32(_ZN18btDbvtTreeCollider7ProcessEPK10btDbvtNode__index__);
emit_32(_ZN6btDbvt8ICollide7ProcessEPK10btDbvtNodef__index__);
emit_32(_ZN6btDbvt8ICollide7DescentEPK10btDbvtNode__index__);
emit_32(_ZN6btDbvt8ICollide9AllLeavesEPK10btDbvtNode__index__);
emit_start(_ZTI18btDbvtTreeCollider)
emit_32(_ZTVN10__cxxabiv120__si_class_type_infoE+8);
emit_32(_ZTS18btDbvtTreeCollider);
emit_32(_ZTIN6btDbvt8ICollideE);
emit_start(_ZTS18btDbvtTreeCollider)
emit_string('18btDbvtTreeCollider\x00');
emit_start(_ZTV19BroadphaseRayTester)
emit_32(0);
emit_32(_ZTI19BroadphaseRayTester);
emit_32(_ZN19BroadphaseRayTesterD1Ev__index__);
emit_32(_ZN19BroadphaseRayTesterD0Ev__index__);
emit_32(_ZN6btDbvt8ICollide7ProcessEPK10btDbvtNodeS3___index__);
emit_32(_ZN19BroadphaseRayTester7ProcessEPK10btDbvtNode__index__);
emit_32(_ZN6btDbvt8ICollide7ProcessEPK10btDbvtNodef__index__);
emit_32(_ZN6btDbvt8ICollide7DescentEPK10btDbvtNode__index__);
emit_32(_ZN6btDbvt8ICollide9AllLeavesEPK10btDbvtNode__index__);
emit_start(_ZTI19BroadphaseRayTester)
emit_32(_ZTVN10__cxxabiv120__si_class_type_infoE+8);
emit_32(_ZTS19BroadphaseRayTester);
emit_32(_ZTIN6btDbvt8ICollideE);
emit_start(_ZTS19BroadphaseRayTester)
emit_string('19BroadphaseRayTester\x00');
emit_start


omerular filtration rate/1.73 sq M.predicted [Volume Rate/Area] in Serum or Plasma by Creatinine-based formula (MDRD) (Details : {LOINC code '33914-3' = 'Glomerular filtration rate/1.73 sq M.predicted by Creatinine-based formula (MDRD)', given as 'Glomerular filtration rate/1.73 sq M.predicted [Volume Rate/Area] in Serum or Plasma by Creatinine-based formula (MDRD)'})

subject: Roel

issued: 04/04/2013 2:34:00 PM

performer: Luigi Maas

interpretation: interpretation of results should be assigned based upon the level of kindey function (Details )

note: GFR estimating equations developed by the Modification of Diet in Renal Disease (MDRD) Study Group and the Chronic Kidney Disease Epidemiology Collaboration (CKD-EPI)....

method: MDRD (Details : {SNOMED CT code '702668005' = 'Modification of diet in renal disease formula', given as 'MDRD'})

component

code: Glomerular filtration rate/1.73 sq M predicted among blacks [Volume Rate/?Area] in Serum or Plasma by Creatinine-based formula (MDRD) (Details : {LOINC code '48643-1' = 'Glomerular filtration rate/1.73 sq M predicted among blacks by Creatinine-based formula (MDRD)', given as 'Glomerular filtration rate/1.73 sq M predicted among blacks [Volume Rate/?Area] in Serum or Plasma by Creatinine-based formula (MDRD)'})

value: >60 mL/min/1.73m2 (Details: UCUM code mL/min/{1.73_m2} = 'mL/min/{1.73_m2}')

ReferenceRanges

-

*

component

code: Glomerular filtration rate/1.73 sq M predicted among non-blacks [Volume Rate/Area] in Serum or Plasma by Creatinine-based formula (MDRD) (Details : {LOINC code '48642-3' = 'Glomerular filtration rate/1.73 sq M predicted among non-blacks by Creatinine-based formula (MDRD)', given as 'Glomerular filtration rate/1.73 sq M predicted among non-blacks [Volume Rate/Area] in Serum or Plasma by Creatinine-based formula (MDRD)'})

value: 60 mL/min/1.73m2 (Details: UCUM code mL/min/{1.73_m2} = 'mL/min/{1.73_m2}')

ReferenceRanges

-

*

Usage note: every effort has been made to ensure that the
examples are correct and useful, but they are not a normative part
of the specification.


local substitute = require("substitute")

local function execute_keys(feedkeys)
  local keys = vim.api.nvim_replace_termcodes(feedkeys, true, false, true)
  vim.api.nvim_feedkeys(keys, "x", false)
end

local function get_buf_lines()
  return vim.api.nvim_buf_get_lines(0, 0, -1, true)
end

local buf
describe("Substitute modifiers", function()
  before_each(function()
    substitute.setup()

    buf = vim.api.nvim_create_buf(false, true)
    vim.api.nvim_command("buffer " .. buf)
  end)

  it("should be taken from a function", function()
    vim.api.nvim_buf_set_lines(buf, 0, -1, true, { "Lorem", "ipsum", "dolor", "sit", "amet" })

    vim.keymap.set({ "n", "x" }, "]s", function()
      require("substitute").operator({
        modifiers = function(_)
          return { "linewise" }
        end,
      })
    end,


ons.gson.AddGsonAnnotationInterceptor
import wu.seal.jsontokotlin.test.TestConfig

class MinimalAnnotationInterceptorTest {

    private val json ="""
        {
            "a": 1,
             "a_b": 2,
             "a c": 3
        }
    """.trimIndent()

    private val excepted = """data class Test(
    val a: Int, // 1
    @SerializedName("a_b")
    val aB: Int, // 2
    @SerializedName("a c")
    val aC: Int // 3
)"""
    @Before
    fun setUp() {
        TestConfig.setToTestInitState()
    }

    @Test
    fun intercept() {
        val generateKotlinDataClass = json.generateKotlinDataClass()
        val interceptedDataClass = generateKotlinDataClass.applyInterceptor(AddGsonAnnotationInterceptor())
        .applyInterceptor(MinimalAnnotationKotlinClassInterceptor())

        interceptedDataClass.getCode().should.be.equal(excepted)
    }
}

package wu.seal.jsontokotlin.feedback

import com.google.gson.Gson
import com.winterbe.expekt.should
import org.junit.AfterClass
import org.junit.Before
import org.junit.Test
import wu.seal.jsontokotlin.test.TestConfig.isTestModel

/**
 *
 * Created by Seal.Wu on 2018/2/6.
 */
class PersistCacheTest {

    private val exceptionInfo = "Test exception"

    @Before
    fun before() {
        isTestModel = true
    }

    @Test
    fun saveExceptionInfo() {
        PersistCache.saveExceptionInfo(exceptionInfo)
    }

    @Test
    fun readAllCachedExceptionInfo() {
        PersistCache.readAllCachedExceptionInfo()
    }

    @Test
    fun deleteAllExceptionInfoCache() {
        PersistCache.deleteAllExceptionInfoCache()
    }

    @Test
    fun saveActionInfo() {
        PersistCache.saveActionInfo(Gson().toJson(StartAction()))
    }

    @Test
    fun readAllCachedActionInfo() {
        PersistCache.readAllCachedActionInfo()
    }

    @Test
    fun deleteAllActionInfo() {
        PersistCache.deleteAllActionInfo()
    }

    @Test
    fun testSaveActionInfoAndReadActionInfo() {

        val startActionJSONString = Gson().toJson(StartAction())

        PersistCache.saveActionInfo(startActionJSONString)

        val readStartActionJSONString = PersistCache.readAllCachedActionInfo().dropLast(1)

        readStartActionJSONString.should.be.equal(startActionJSONString)

    }

    @Test
    fun testSaveExceptionInfoAndReadExceptionInfo() {

        PersistCache.saveExceptionInfo(exceptionInfo)

        val readExceptionInfo = PersistCache.readAllCachedExceptionInfo().dropLast(1)

        readExceptionInfo.should.be.equal(exceptionInfo)

    }

    companion object {
        @AfterClass
        @JvmStatic
        fun afterClass() {
            PersistCache.deleteAllActionInfo()
            PersistCache.deleteAllExceptionInfoCache()
        }
    }
}package wu.seal.jsontokotlin.regression

import com.winterbe.expekt.should
import org.junit.Test
import wu.seal.jsontokotlin.KotlinCodeMaker
import wu.seal.jsontokotlin.test.TestConfig

class Issue295Test {

    @Test
    fun testDoubleTypeInArray() {

        TestConfig.setToTestInitState()

        val json = """
            {
            "arr": [10, ${Long.MAX_VALUE}, 11.2]
            }
        """.trimIndent()
        val resultCode = KotlinCodeMaker("A", json).makeKotlinData().trimIndent()
        val expectCode = """
            data class A(
                @SerializedName("arr


_max = 5000,
		spawn_bound = "cannon",
		fire_sfx = "battle/cannon-main",
		queue = 1,
		id = 2965094,
		type = 1,
		action_index = "stand",
		bullet_ID = {
			29643013
		},
		barrage_ID = {
			29643020
		}
	}
	uv0.weapon_property_400[2965100] = {
		aim_type = 0,
		range = 120,
		damage = 2,
		base = 1000,
		name = "【大世界】黑方舟 第三波 步枪弹幕 LV1",
		fire_fx = "CAFire",
		suppress = 0,
		reload_max = 30,
		spawn_bound = "cannon",
		fire_sfx = "battle/cannon-main",
		queue = 1,
		id = 2965100,
		type = 1,
		action_index = "",
		bullet_ID = {
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017
		},
		barrage_ID = {
			29643022,
			29643023,
			29643024,
			29643025,
			29643026,
			29643027,
			29643028,
			29643029,
			29643030,
			29643031,
			29643032,
			29643033,
			29643034,
			29643035,
			29643036,
			29643037,
			29643038,
			29643039,
			29643040,
			29643041,
			29643042,
			29643043,
			29643044,
			29643045
		}
	}
	uv0.weapon_property_400[2965101] = {
		aim_type = 0,
		range = 120,
		damage = 4,
		base = 1000,
		name = "【大世界】黑方舟 第三波 步枪弹幕 LV2",
		fire_fx = "CAFire",
		suppress = 0,
		reload_max = 30,
		spawn_bound = "cannon",
		fire_sfx = "battle/cannon-main",
		queue = 1,
		id = 2965101,
		type = 1,
		action_index = "",
		bullet_ID = {
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017,
			29643014,
			29643015,
			29643016,
			29643017
		},
		barrage_ID = {
			29643022,
			29643023,
			29643024,
			29643025,
			29643026,
			29643027,
			29643028,
			29643029,
			29643030,
			29643031,
			29643032,
			29643033,


-align: center;
      align-self: center;
  outline: none;
  border: 2px solid #919090;
  border-radius: 255px 15px 225px 15px/15px 225px 15px 255px;
  /*
      Above is shorthand for:
      border-top-left-radius: 255px 15px;
      border-top-right-radius: 15px 225px;
      border-bottom-right-radius: 225px 15px;
      border-bottom-left-radius:15px 255px;
      */
}

input.lined.thick,
textarea.lined.thick,
keygen.lined.thick,
select.lined.thick,
button.lined.thick,
table.lined.thick,
.hd-border.lined.thick,
fieldset.lined.thick,
.checkbox > input[type="checkbox"] + label:before.lined.thick,
.radio > input[type="radio"] + label:before.lined.thick {
  border: solid 7px #41403E;
}

input.dotted.thick,
textarea.dotted.thick,
keygen.dotted.thick,
select.dotted.thick,
button.dotted.thick,
table.dotted.thick,
.hd-border.dotted.thick,
fieldset.dotted.thick,
.checkbox > input[type="checkbox"] + label:before.dotted.thick,
.radio > input[type="radio"] + label:before.dotted.thick {
  border: dotted 5px #41403E;
}

input.dashed.thick,
textarea.dashed.thick,
keygen.dashed.thick,
select.dashed.thick,
button.dashed.thick,
table.dashed.thick,
.hd-border.dashed.thick,
fieldset.dashed.thick,
.checkbox > input[type="checkbox"] + label:before.dashed.thick,
.radio > input[type="radio"] + label:before.dashed.thick {
  border: dashed 5px #41403E;
}

input.lined.thin,
textarea.lined.thin,
keygen.lined.thin,
select.lined.thin,
button.lined.thin,
table.lined.thin,
.hd-border.lined.thin,
fieldset.lined.thin,
.checkbox > input[type="checkbox"] + label:before.lined.thin,
.radio > input[type="radio"] + label:before.lined.thin {
  border: solid 2px #41403E;
}

input.dotted.thin,
textarea.dotted.thin,
keygen.dotted.thin,
select.dotted.thin,
button.dotted.thin,
table.dotted.thin,
.hd-border.dotted.thin,
fieldset.dotted.thin,
.checkbox > input[type="checkbox"] + label:before.dotted.thin,
.radio > input[type="radio"] + label:before.dotted.thin {
  border: dotted 2px #41403E;
}

input.dashed.thin,
textarea.dashed.thin,
keygen.dashed.thin,
select.dashed.thin,
button.dashed.thin,
table.dashed.thin,
.hd-border.dashed.thin,
fieldset.dashed.thin,
.checkbox > input[type="checkbox"] + label:before.dashed.thin,
.radio > input[type="radio"] + label:before.dashed.thin {
  border: dashed 2px #41403E;
}

body,
a,
input,
select,
button,
textarea {
  color: #717171;
}

/**/
input[type=button],
button {
  background: #919090;
  cursor: pointer;
  color: white;
}

/* Tables */
thead tr th {
  border-bottom: 2px solid #919090;
  box-shadow: 20px 38px 34px -


yer"]
		except KeyError:
			pass

	def ParseGCodeMove(self, gcm):
		if "homing_origin" in gcm:
			self.GCHomeOrigin = gcm["homing_origin"]

		if "position" in gcm:
			self.GCPosition = gcm["position"]
		if "gcode_position" in gcm:
			self.GCGPosition = gcm["gcode_position"]

		try:
			zo = self.GCPosition[2] - self.GCGPosition[2]
		except Exception as e:
			self.parent.LogItem("Exception %s encountered trying to calculate z offset" % str(e))
			return

		self.zoffset = zo
		self.stZOffset.SetLabel("%6.3f" % self.zoffset)

	def setJobStatus(self, active, fn, pos, prog):
		self.jobStatus = active
		self.fpos = pos
		self.progress = prog
		self.ShowProgress()

	def ShowProgress(self):
		pct = self.progress * 100.0
		self.Gauge.SetValue(round(pct))
		self.Percent.SetLabel("%5.2f%%" % pct)

	def UpdateStatus(self, jmsg):
		if "toolhead" in jmsg:
			try:
				pos = jmsg["toolhead"]["position"]
			except KeyError:
				pos = None

			if pos is not None:
				self.toolPosition = pos
				self.UpdateToolPosition()

			try:
				axes = jmsg["toolhead"]["homed_axes"]
			except KeyError:
				axes = None

			if axes is not None:
				if axes != self.homedAxes:
					self.homedAxes = axes
					self.UpdateHomedAxes()

		if "print_stats" in jmsg:
			self.ParsePrintStats(jmsg["print_stats"])

		if "gcode_move" in jmsg:
			self.ParseGCodeMove(jmsg["gcode_move"])

	def RefreshFilesList(self):
		pass


Values(@"test.txt")]string path)
        {
            var environment = Substitute.For<IEnvironment>();
            environment.RepositoryPath.Returns(repositoryPath.ToNPath());
            environment.UnityProjectPath.Returns(projectPath.ToNPath());

            environment.GetRepositoryPath(path.ToNPath());
        }

        [Test, Sequential]
        public void GetAssetPathReturnsRelativePathToProject(
            [Values(@"c:\Projects", "/Projects", "/UnityProject")] string repositoryPath,
            [Values(@"c:\Projects\UnityProject", "/Projects/Unity/UnityProject", "/UnityProject")] string projectPath,
            [Values(@"UnityProject\test.txt", "Unity/UnityProject/Assets/test.txt", "test.txt")] string path,
            [Values("test.txt", "Assets/test.txt", "test.txt")] string expected)
        {
            var environment = Substitute.For<IEnvironment>();
            environment.RepositoryPath.Returns(repositoryPath.ToNPath());
            environment.UnityProjectPath.Returns(projectPath.ToNPath());

            NPath nExpected = expected.ToNPath();
            var repositoryFilePath = environment.GetAssetPath(path.ToNPath());
            repositoryFilePath.Should().Be(nExpected);
        }

        [Test]
        [ExpectedException(ExpectedException = typeof(InvalidOperationException))]
        public void GetAssetPathShouldThrowWhenRepositoryRootIsChild(
            [Values(@"c:\Projects\UnityProject\Assets")] string repositoryPath,
            [Values(@"c:\Projects\UnityProject")] string projectPath,
            [Values("test.txt")] string path)
        {
            var environment = Substitute.For<IEnvironment>();
            environment.RepositoryPath.Returns(repositoryPath.ToNPath());
            environment.UnityProjectPath.Returns(projectPath.ToNPath());

            environment.GetAssetPath(path.ToNPath());
        }
    }
}


鸣声（等于pewit）",
"peewitted":"(peewit 的过去时) n.(=pewit)田凫, 田凫的鸣声",
"pef":"abbr. peak expiratory flow 最大呼气流量; personal effects floater (policy) 私人物品保险，私人行李保险",
"peffer":" [人名] [英格兰人姓氏] 佩弗 Pepper的变体",
"peg":"n. 钉, 桩, 栓, 藉口, 销子, 借口\\nvt. 钉木钉, 固定, 限制, 使受约束\\nvi. 坚持不懈地奋力于, 疾行",
"peg at":"敲打,夯;使固定在…;追求…",
"peg away":" （非正式）（尤指长期）坚持不懈地工作, 勤奋地工作",
"peg away at":"集中力量于,埋头做,孜孜从事",
"peg cells":"[医] 闰细胞",
"peg count":"[计] 占线计数",
"peg down":"v. 用木钉钉住",
"peg leg":"n. 木制假腿",
"peg out":"死亡",
"peg point":"[经] 标准点, 标定点",
"peg sb down to sth":"约束某人做某事,使某人保证做某事",
"peg sb dwon":"约束某人的行动",
"peg top":"陀螺形裤子",
"peg wire":"[机] 固钉铁丝",
"peg-down":"用木钉钉住；约束",
"peg-leg":"木制义肢",
"peg-shaped incisor":"[医] 钉状切牙, 钉状门齿",
"peg-top":"a. (裙子、裤子等)上宽下窄的",
"peg-topped":"a. 陀螺形的, 上宽下窄的(尤指臀部宽大, 踝部狭小的裤子)",
"pegamoid":"人造革, 防水布",
"peganine":"(=Vasicine)骆驼蓬碱, 瓦丝素",
"peganone":"(=ethotoin)皮加隆, 乙妥英(抗惊厥药)",
"Peganum harmala":"[医] 骆驼蓬",
"pegasi":" 室宿二",
"pegasid":"海蛾鱼",
"pegasus":"n. 诗兴, 诗才",
"pegboard":"n. （玩游戏用的）小钉板；木栓板",
"pegbox":"n. (弦乐器的)弦轴箱,栓斗",
"pegem":"abbr. post engagement ground effects model 交战后地面影响模型",
"Pegg":"n. (Pegg)人名；(英、法、西)佩格",
"pegged":"v. 用夹子或钉子固定( peg的过去式和过去分词 ); 使固定在某水平",
"pegged exchange rate":"[经] 钉住的汇率",
"pegged-d


()
                - getPaddingRight();
        final int childHeight = child.getHeight() - getPaddingTop()
                - getPaddingBottom();
        child.layout(childLeft, childTop, childLeft + childWidth, childTop
                + childHeight);

        int headViewWidth = mHeadViewContainer.getMeasuredWidth();
        int headViewHeight = mHeadViewContainer.getMeasuredHeight();
        mHeadViewContainer.layout((width / 2 - headViewWidth / 2),
                -headViewHeight, (width / 2 + headViewWidth / 2), 0);// 更新头布局的位置
        int footViewWidth = mFooterViewContainer.getMeasuredWidth();
        int footViewHeight = mFooterViewContainer.getMeasuredHeight();
        mFooterViewContainer.layout((width / 2 - footViewWidth / 2), height,
                (width / 2 + footViewWidth / 2), height + footViewHeight);
    }

    private final Animation mAnimateToCorrectPosition = new Animation() {
        @Override
        public void applyTransformation(float interpolatedTime, Transformation t) {
            int targetTop = 0;
            int endTarget = 0;
            if (!mUsingCustomStart) {
                endTarget = (int) (mSpinnerFinalOffset - Math
                        .abs(mOriginalOffsetTop));
            } else {
                endTarget = (int) mSpinnerFinalOffset;
            }
            targetTop = (mFrom + (int) ((endTarget - mFrom) * interpolatedTime));
            int offset = targetTop - mHeadViewContainer.getTop();
            setTargetOffsetTopAndBottom(offset, false /* requires update */);
        }

        @Override
        public void setAnimationListener(AnimationListener listener) {
            super.setAnimationListener(listener);
        }
    };

    private void moveToStart(float interpolatedTime) {
        int targetTop = 0;
        targetTop = (mFrom + (int) ((mOriginalOffsetTop - mFrom) * interpolatedTime));
        int offset = targetTop - mHeadViewContainer.getTop();
        setTargetOffsetTopAndBottom(offset, false /* requires update */);
    }

    private final Animation mAnimateToStartPosition = new Animation() {
        @Override
        public void applyTransformation(float interpolatedTime, Transformation t) {
            moveToStart(interpolatedTime);
        }
    };

    private void startScaleDownReturnToStartAnimation(int from,
                                                      AnimationListener listener) {
        mFrom = from;
        mStartingScale = ViewCompat.getScaleX(mHeadViewContainer);
        mScaleDownToStartAnimation = new Animation() {
            @Override
            public void applyTransformation(float interpolatedTime,
                                            Transformation t) {
                float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
                setAnimationProgress(targetScale);
                moveToStart(interpolatedTime);
            }
        };
        mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
        if (listener != null) {
            mHeadViewContainer.setAnimationListener(listener);
        }
        mHeadViewContainer.clearAnimation();
        mHeadViewContainer.startAnimation(mScaleDownToStartAnimation);
    }

    private void setTargetOffsetTopAndBottom(int offset, boolean requiresUpdate) {
        mHeadViewContainer.bringToFront();
        mHeadViewContainer.offsetTopAndBottom(offset);
        mCurrentTargetOffsetTop = mHeadViewContainer.getTop();
        if (requiresUpdate && Build.VERSION.SDK_INT < 11) {
            invalidate();
        }
        updateListenerCallBack();
    }

    /**
     * 修改底部布局的位置-敏感pushDistance
     */
    private void updateFooterViewPosition() {
        mFooterViewContainer.setVisibility(View.VISIBLE);
        mFooterViewContainer.bringToFront();
        mFooterView


          BY_NAME_DESC -> {
                Collections.sort(fileList, SortByName())
                fileList.reverse()
            }
            BY_TIME_ASC -> Collections.sort(fileList, SortByTime())
            BY_TIME_DESC -> {
                Collections.sort(fileList, SortByTime())
                fileList.reverse()
            }
            BY_SIZE_ASC -> Collections.sort(fileList, SortBySize())
            BY_SIZE_DESC -> {
                Collections.sort(fileList, SortBySize())
                fileList.reverse()
            }
            BY_EXTENSION_ASC -> Collections.sort(fileList, SortByExtension())
            BY_EXTENSION_DESC -> {
                Collections.sort(fileList, SortByExtension())
                fileList.reverse()
            }
        }
        return fileList.toTypedArray()
    }

    /**
     * 列出指定目录下的所有文件
     */
    fun listFiles(startDirPath: String, allowExtensions: Array<String>?): Array<File>? {
        val file = File(startDirPath)
        return file.listFiles { _, name ->
            //返回当前目录所有以某些扩展名结尾的文件
            val extension = getExtension(name)
            allowExtensions?.contentDeepToString()?.contains(extension) == true
                    || allowExtensions == null
        }
    }

    /**
     * 列出指定目录下的所有文件
     */
    fun listFiles(startDirPath: String, allowExtension: String?): Array<File>? {
        return if (allowExtension == null)
            listFiles(startDirPath, allowExtension = null)
        else
            listFiles(startDirPath, arrayOf(allowExtension))
    }

    /**
     * 判断文件或目录是否存在
     */
    fun exist(path: String): Boolean {
        val file = File(path)
        return file.exists()
    }

    /**
     * 删除文件或目录
     */
    @JvmOverloads
    fun delete(file: File, deleteRootDir: Boolean = false): Boolean {
        var result = false
        if (file.isFile) {
            //是文件
            result = deleteResolveEBUSY(file)
        } else {
            //是目录
            val files = file.listFiles() ?: return false
            if (files.isEmpty()) {
                result = deleteRootDir && deleteResolveEBUSY(file)
            } else {
                for (f in files) {
                    delete(f, deleteRootDir)
                    result = deleteResolveEBUSY(f)
                }
            }
            if (deleteRootDir) {
                result = deleteResolveEBUSY(file)
            }
        }
        return result
    }

    /**
     * bug: open failed: EBUSY (Device or resource busy)
     * fix: http://stackoverflow.com/questions/11539657/open-failed-ebusy-device-or-resource-busy
     */
    private fun deleteResolveEBUSY(file: File): Boolean {
        // Before you delete a Directory or File: rename it!
        val to = File(file.absolutePath + System.currentTimeMillis())

        file.renameTo(to)
        return to.delete()
    }

    /**
     * 删除文件或目录
     */
    @JvmOverloads
    fun delete(path: String, deleteRootDir: Boolean = true): Boolean {
        val file = File(path)

        return if (file.exists()) {
            delete(file, deleteRootDir)
        } else false
    }

    /**
     * 复制文件为另一个文件，或复制某目录下的所有文件及目录到另一个目录下
     */
    fun copy(src: String, tar: String): Boolean {
        val srcFile = File(src)
        return srcFile.exists() && copy(srcFile, File(tar))
    }

    /**
     * 复制文件或目录
     */
    fun copy(src: File, tar:


  get => fields.LanguageId[this];
            set => fields.LanguageId[this] = value;
        }

        [DisplayName("Category Name"), Size(15), QuickSearch, NameProperty]
        public String CategoryName
        {
            get => fields.CategoryName[this];
            set => fields.CategoryName[this] = value;
        }

        [DisplayName("Description")]
        public String Description
        {
            get => fields.Description[this];
            set => fields.Description[this] = value;
        }

        public Field CultureIdField
        {
            get => fields.LanguageId;
        }

        public CategoryLangRow()
        {
        }

        public CategoryLangRow(RowFields fields)
            : base(fields)
        {
        }

        public class RowFields : RowFieldsBase
        {
            public Int32Field Id;
            public Int32Field CategoryId;
            public Int32Field LanguageId;
            public StringField CategoryName;
            public StringField Description;
        }
    }
}


精華", {"我幾個星期來都在研究燃燒平原的龍類，而且我終於有所突破了！我制作了壹個裝置——我把它叫做“龍靈采集器900型”，它可以采集雛龍的精華！","好吧，至少我認為它可以實現這個功能。","給妳，拿著這個裝置，然後到燃燒平原上去采集雛龍精華。首先使用它標記雛龍，然後再殺死被標記的雛龍，這樣妳就可以采集雛龍精華了。","如果壹切正常的話，那就太棒了！把妳采集的東西帶回來供我進行研究！"}, {"將龍靈采集器900型和8份雛龍精華交給燃燒平原烈焰峰的丁奇·斯迪波爾。"}},
[4727] = {"擱淺的海龜", {"壹只海龜的骸骨躺在黑海岸北部的沙灘上。也許灰霧魚人沒有發現它的屍體，或者由於某些特殊的原因而沒有去碰它。不管怎麽樣，這具屍體上有足夠的海龜肉，妳可以采集壹些作為樣本，並把它送到奧伯丁的溫尼斯·布萊葛那裏，供月神殿進行研究。"}, {"把海龜的殘骸交給奧伯丁的溫尼斯·布萊葛。"}},
[4728] = {"擱淺的海洋生物", {"某種海中巨獸的屍體擱淺在了海灘上，壹只帶著輪子的木桶和其它壹些雜七雜八的工具散布在這頭巨獸旁邊，看來曾經有什麽人想要研究它。雖然這具屍體被魚人吃得差不多只剩骨頭了，但是剩下的殘骸也足夠讓妳取樣並送到奧伯丁的溫尼斯·布萊葛那裏去。"}, {"把海洋生物的骸骨交給奧伯丁的溫尼斯·布萊葛。"}},
[4729] = {"基布雷爾的特殊寵物", {"妳也許想要知道我在這裏幹什麽。看看這些籠子！難道這還不夠明顯嗎？","我是個動物愛好者，但是首先我是個商人。我為壹些富翁和名流尋找珍貴的動物，然後把它們馴化成為溫順的寵物。","也


dWithSucc());
    MachineBasicBlock::instr_iterator II = Br.getInstrIterator();
    MIBundleBuilder(&*MIB).append((++II)->removeFromBundle());
  }
  Br->eraseFromParent();
}

bool MipsBranchExpansion::buildProperJumpMI(MachineBasicBlock *MBB,
                                            MachineBasicBlock::iterator Pos,
                                            DebugLoc DL) {
  bool HasR6 = ABI.IsN64() ? STI->hasMips64r6() : STI->hasMips32r6();
  bool AddImm = HasR6 && !STI->useIndirectJumpsHazard();

  unsigned JR = ABI.IsN64() ? Mips::JR64 : Mips::JR;
  unsigned JIC = ABI.IsN64() ? Mips::JIC64 : Mips::JIC;
  unsigned JR_HB = ABI.IsN64() ? Mips::JR_HB64 : Mips::JR_HB;
  unsigned JR_HB_R6 = ABI.IsN64() ? Mips::JR_HB64_R6 : Mips::JR_HB_R6;

  unsigned JumpOp;
  if (STI->useIndirectJumpsHazard())
    JumpOp = HasR6 ? JR_HB_R6 : JR_HB;
  else
    JumpOp = HasR6 ? JIC : JR;

  if (JumpOp == Mips::JIC && STI->inMicroMipsMode())
    JumpOp = Mips::JIC_MMR6;

  unsigned ATReg = ABI.IsN64() ? Mips::AT_64 : Mips::AT;
  MachineInstrBuilder Instr =
      BuildMI(*MBB, Pos, DL, TII->get(JumpOp)).addReg(ATReg);
  if (AddImm)
    Instr.addImm(0);

  return !AddImm;
}

// Expand branch instructions to long branches.
// TODO: This function has to be fixed for beqz16 and bnez16, because it
// currently assumes that all branches have 16-bit offsets, and will produce
// wrong code if branches whose allowed offsets are [-128, -126, ..., 126]
// are present.
void MipsBranchExpansion::expandToLongBranch(MBBInfo &I) {
  MachineBasicBlock::iterator Pos;
  MachineBasicBlock *MBB = I.Br->getParent(), *TgtMBB = getTargetMBB(*I.Br);
  DebugLoc DL = I.Br->getDebugLoc();
  const BasicBlock *BB = MBB->getBasicBlock();
  MachineFunction::iterator FallThroughMBB = ++MachineFunction::iterator(MBB);
  MachineBasicBlock *LongBrMBB = MFp->CreateMachineBasicBlock(BB);

  MFp->insert(FallThroughMBB, LongBrMBB);
  MBB->replaceSuccessor(TgtMBB, LongBrMBB);

  if (IsPIC) {
    MachineBasicBlock *BalTgtMBB = MFp->CreateMachineBasicBlock(BB);
    MFp->insert(FallThroughMBB, BalTgtMBB);
    LongBrMBB->addSuccessor(BalTgtMBB);
    BalTgtMBB->addSuccessor(TgtMBB);

    // We must select between the MIPS32r6/MIPS64r6 BALC (which is a normal
    // instruction) and the pre-MIPS32r6/MIPS64r6 definition (which is an
    // pseudo-instruction wrapping BGEZAL).
    const unsigned BalOp =
        STI->hasMips32r6()
            ? STI->inMicroMipsMode() ? Mips::BALC_MMR6 : Mips::BALC
            : STI->inMicroMipsMode() ? Mips::BAL_BR_MM : Mips::BAL_BR;

    if (!ABI.IsN64()) {
      // Pre R6:
      // $longbr:
      //  addiu $sp, $sp, -8
      //  sw $ra, 0($sp)
      //  lui $at, %hi($tgt - $baltgt)
      //  bal $baltgt
      //  addiu $at, $at, %lo($tgt - $baltgt)
      // $baltgt:
      //  addu $at


91,
			MaksRUD = 0.85,
			MaxRUD = 1,
			MinRUD = 0,
			Nmg = 60.00001,
			cefor = 2.56,
			cemax = 1.24,
			dcx_eng = 0.0085,
			dpdh_f = 6200,
			dpdh_m = 3000,
			hMaxEng = 19.5,
			table_data = { { 0, 77070.4, 146000 }, { 0.2, 72000, 138000 }, { 0.4, 70000, 137000 }, { 0.6, 70000, 135000 }, { 0.7, 72000, 135000 }, { 0.8, 72000, 140000 }, { 0.9, 70000, 146000 }, { 1, 64000, 149000 }, { 1.1, 58000, 152000 }, { 1.2, 57000, 155000 }, { 1.3, 57000, 160000 }, { 1.4, 55000, 165000 }, { 1.596, 50000, 162000 }, { 1.8, 44000, 146000 }, { 2.2, 49000, 127000 }, { 2.35, 47000, 127000 }, { 3.9, 90381.1, 130000 } },
			type = "TurboJet"
		}
	},
	Sensors = {
		OPTIC = "Tornado GR_4 FLIR",
		RADAR = "Tornado SS radar",
		RWR = "Abstract RWR"
	},
	Shape = "TORNADO",
	Tasks = { {
			Name = "Pinpoint Strike",
			OldID = "Pinpoint Strike",
			WorldID = 33
		}, <table 1>, {
			Name = "SEAD",
			OldID = "SEAD",
			WorldID = 29
		}, {
			Name = "AFAC",
			OldID = "AFAC",
			WorldID = 16
		}, {
			Name = "Anti-ship Strike",
			OldID = "Antiship Strike",
			WorldID = 30
		}, {
			Name = "Reconnaissance",
			OldID = "Reconnaissance",
			WorldID = 17
		} },
	V_land = 59,
	V_max_h = 650,
	V_max_sea_level = 306,
	V_opt = 120,
	V_take_off = 59,
	Vy_max = 250,
	Waypoint_Custom_Panel = true,
	WingSpan = "13.91",
	WorldID = 10,
	_file = "Scripts/Database/planes\\Tornado_GR4.lua",
	air_refuel_receptacle_pos = { 6.4, 0.63, 1.02 },
	attribute = { 1, 1, 1, "Redacted", "Bombers", "Datalink", "Link16", "Refuelable", "All", "NonAndLightArmoredUnits", "NonArmoredUnits", "Air", "Planes", "Battle airplanes" },
	average_fuel_consumption = 0.61,
	bank_angle_max = 60,
	bigParkingRamp = false,
	brakeshute_name = 0,
	country_of_origin = "UK",
	crew_members = { {
			canopy_arg = 38,
			drop_canopy_name = 39,
			ejection_seat_name = 9,
			pos = <7>{ 3.34, 1.102, 0 },
			role = "pilot",
			role_display_name = "Pilot in command"
		}, {
			canopy_arg = 38,
			canopy_pos = <table 7>,
			drop_canopy_name = 39,
			ejection_seat_name = 9,
			pos = { 1.935, 1.102, 0 },
			role = "copilot",
			role_display_name = "Copilot"
		} },
	detection_range_max = 150,
	engines_count = 2,
	engines_nozzles = { {
			diameter = 0.818,
			elevation = 0,
			exhaust_length_ab = 4,
			exhaust_length_ab_K = 0.76,
			pos = { -6.45, 0.099, -0.483 },
			smokines


ðŸ” What's Included"},{"level":2,"text":"âœ¨ Features","anchor":"-features","htmlText":"âœ¨ Features"},{"level":2,"text":"ðŸš€ Getting Started","anchor":"-getting-started","htmlText":"ðŸš€ Getting Started"},{"level":2,"text":"ðŸ“– Detailed Usage","anchor":"-detailed-usage","htmlText":"ðŸ“– Detailed Usage"},{"level":3,"text":"Transport Methods","anchor":"transport-methods","htmlText":"Transport Methods"},{"level":3,"text":"Running the Server Locally","anchor":"running-the-server-locally","htmlText":"Running the Server Locally"},{"level":4,"text":"stdio Transport (CLI Mode)","anchor":"stdio-transport-cli-mode","htmlText":"stdio Transport (CLI Mode)"},{"level":4,"text":"HTTP Transport (Web Mode)","anchor":"http-transport-web-mode","htmlText":"HTTP Transport (Web Mode)"},{"level":3,"text":"Connecting to the Server","anchor":"connecting-to-the-server","htmlText":"Connecting to the Server"},{"level":4,"text":"Connecting from Cursor","anchor":"connecting-from-cursor","htmlText":"Connecting from Cursor"},{"level":4,"text":"Using mcp.json with Cursor","anchor":"using-mcpjson-with-cursor","htmlText":"Using mcp.json with Cursor"},{"level":3,"text":"Testing Your Server with CLI Tools","anchor":"testing-your-server-with-cli-tools","htmlText":"Testing Your Server with CLI Tools"},{"level":3,"text":"Using Environment Variables","anchor":"using-environment-variables","htmlText":"Using Environment Variables"},{"level":2,"text":"ðŸ› ï¸ Adding Custom Tools and Resources","anchor":"ï¸-adding-custom-tools-and-resources","htmlText":"ðŸ› ï¸ Adding Custom Tools and Resources"},{"level":3,"text":"Tools","anchor":"tools","htmlText":"Tools"},{"level":3,"text":"Resources","anchor":"resources","htmlText":"Resources"},{"level":3,"text":"Prompts","anchor":"prompts","htmlText":"Prompts"},{"level":2,"text":"ðŸ“š Documentation","anchor":"-documentation","htmlText":"ðŸ“š Documentation"},{"level":2,"text":"ðŸ“„ License","anchor":"-license","htmlText":"ðŸ“„ License"}],"lineInfo":{"truncatedLoc":"285","truncatedSloc":"218"},"mode":"file"},"image":false,"isCodeownersFile":null,"isPlain":false,"isValidLegacyIssueTemplate":false,"issueTemplate":null,"discussionTemplate":null,"language":"Markdown","languageID":222,"large":false,"planSupportInfo":{"repoIsFork":null,"repoOwnedByCurrentUser":null,"requestFullPath":"/mcpdotdirect/template-mcp-server/blob/main/README.md","showFreeOrgGatedFeatureMessage":null,"showPlanSupportBanner":null,"upgradeDataAttributes":null,"upgradePath":null},"publishBannersInfo":{"dismissActionNoticePath":"/settings/dismiss-notice/publish_action_from_dockerfile","releasePath":"/mcpdotdirect/template-mcp-server/releases/new?ma


0:%.*]] = add nsw i32 [[CONV]], 1
// CHECK15-NEXT:    [[CONV11:%.*]] = trunc i32 [[ADD10]] to i16
// CHECK15-NEXT:    store i16 [[CONV11]], ptr [[AA]], align 2, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    [[TMP15:%.*]] = load i8, ptr [[AAA]], align 1, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    [[CONV12:%.*]] = sext i8 [[TMP15]] to i32
// CHECK15-NEXT:    [[ADD13:%.*]] = add nsw i32 [[CONV12]], 1
// CHECK15-NEXT:    [[CONV14:%.*]] = trunc i32 [[ADD13]] to i8
// CHECK15-NEXT:    store i8 [[CONV14]], ptr [[AAA]], align 1, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [10 x i32], ptr [[B]], i32 0, i32 2
// CHECK15-NEXT:    [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX]], align 4, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    [[ADD15:%.*]] = add nsw i32 [[TMP16]], 1
// CHECK15-NEXT:    store i32 [[ADD15]], ptr [[ARRAYIDX]], align 4, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    br label [[OMP_BODY_CONTINUE:%.*]]
// CHECK15:       omp.body.continue:
// CHECK15-NEXT:    br label [[OMP_INNER_FOR_INC:%.*]]
// CHECK15:       omp.inner.for.inc:
// CHECK15-NEXT:    [[TMP17:%.*]] = load i32, ptr [[DOTOMP_IV]], align 4, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    [[ADD16:%.*]] = add i32 [[TMP17]], 1
// CHECK15-NEXT:    store i32 [[ADD16]], ptr [[DOTOMP_IV]], align 4, !llvm.access.group [[ACC_GRP25]]
// CHECK15-NEXT:    br label [[OMP_INNER_FOR_COND]], !llvm.loop [[LOOP26:![0-9]+]]
// CHECK15:       omp.inner.for.end:
// CHECK15-NEXT:    [[TMP18:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4
// CHECK15-NEXT:    [[TMP19:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_1]], align 4
// CHECK15-NEXT:    [[TMP20:%.*]] = load i32, ptr [[DOTCAPTURE_EXPR_]], align 4
// CHECK15-NEXT:    [[SUB17:%.*]] = sub i32 [[TMP19]], [[TMP20]]
// CHECK15-NEXT:    [[SUB18:%.*]] = sub i32 [[SUB17]], 1
// CHECK15-NEXT:    [[ADD19:%.*]] = add i32 [[SUB18]], 1
// CHECK15-NEXT:    [[DIV20:%.*]] = udiv i32 [[ADD19]], 1
// CHECK15-NEXT:    [[MUL21:%.*]] = mul i32 [[DIV20]], 1
// CHECK15-NEXT:    [[ADD22:%.*]] = add i32 [[TMP18]], [[MUL21]]
// CHECK15-NEXT:    store i32 [[ADD22]], ptr [[I5]], align 4
// CHECK15-NEXT:    br label [[SIMD_IF_END]]
// CHECK15:       simd.if.end:
// CHECK15-NEXT:    [[TMP21:%.*]] = load i32, ptr [[A]], align 4
// CHECK15-NEXT:    ret i32 [[TMP21]]
//
//
// CHECK15-LABEL: define {{[^@]+}}@_Z9ftemplateIiET_i
// CHECK15-SAME: (i32


,
[81757] = "Spallières des plaines Sauvages",
[81758] = "Epaulières lourdes de Pied de Foudre",
[81759] = "Epaulières cuirassées Chant du Soleil",
[81760] = "Robe en satin des maîtres de la soie",
[81761] = "Cuirasse d’Aquasoleil",
[81762] = "Armure de Huangtze en écailles",
[81763] = "Corselet bruni de Paoquan",
[81764] = "Robe en soie du delta Doré",
[81765] = "Tunique de faucon des plaines",
[81766] = "Corselet des plaines Sauvages",
[81767] = "Plastron lourd de Pied de Foudre",
[81768] = "Plastron cuirassé Chant du Soleil",
[81769] = "Jambières en satin des maîtres de la soie",
[81770] = "Garde-jambes d’Aquasoleil",
[81771] = "Jambières de Huangtze en écailles",
[81772] = "Cuissards brunis de Paoquan",
[81773] = "Chausses en soie du delta Doré",
[81774] = "Garde-jambes de faucon des plaines",
[81775] = "Garde-jambes des plaines Sauvages",
[81776] = "Garde-jambes lourds de Pied de Foudre",
[81777] = "Garde-jambes cuirassés Chant du Soleil",
[81778] = "Bottines en satin des maîtres de la soie",
[81779] = "Protège-tibias d’Aquasoleil",
[81780] = "Solerets de Huangtze en écailles",
[81781] = "Grèves brunies de Paoquan",
[81782] = "Bottines en soie du delta Doré",
[81783] = "Bottes de faucon des plaines",
[81784] = "Solerets des plaines Sauvages",
[81785] = "Bottes de guerre lourdes de Pied de Foudre",
[81786] = "Bottes de guerre cuirassées Chant du Soleil",
[81787] = "Corde en satin des maîtres de la soie",
[81788] = "Ceinture d’Aquasoleil",
[81789] = "Sangle de Huangtze en écailles",
[81790] = "Fermoir bruni de Paoquan",
[81791] = "Corde en soie du delta Doré",
[81792] = "Ceinture de faucon des plaines",
[81793] = "Ceinture des plaines Sauvages",
[81794] = "Ceinturon lourd de Pied de Foudre",
[81795] = "Ceinturon cuirassé Chant du Soleil",
[81796] = "Gants en satin des maîtres de la soie",
[81797] = "Gants d’Aquasoleil",
[81798] = "Gantelets de Huangtze en écailles",
[81799] = "Gants brunis de Paoquan",
[81800] = "Garde-mains en soie du delta Doré",
[81801] = "Gants de faucon des plaines",
[81802] = "Gantelets des plaines Sauvages",
[81803] = "Gantelets lourds de Pied de Foudre",
[81804] = "Gantelets cuirassés Chant du Soleil",
[81805] = "Crispins en satin des maîtres de la soie",
[81806] = "Manchettes d’Aquasoleil",
[81807] = "Bracières de Huangtze en écailles",
[81808] = "Brassards brunis de Paoquan",
[81809] =