tockChart, chartConfig: TimeBarConfig) :
    BaseChildChart<TimeBarConfig>(stockChart, chartConfig) {

    private val tmpDate by lazy { Date() }

    private val labelPaint by lazy { Paint(Paint.ANTI_ALIAS_FLAG) }
    private val highlightLabelPaint by lazy { Paint(Paint.ANTI_ALIAS_FLAG) }
    private val highlightLabelBgPaint by lazy { Paint(Paint.ANTI_ALIAS_FLAG) }

    override fun onKEntitiesChanged() {
    }

    override fun getYValueRange(startIndex: Int, endIndex: Int, result: FloatArray) {
    }

    override fun preDrawBackground(canvas: Canvas) {
    }

    override fun drawBackground(canvas: Canvas) {
        canvas.drawColor(chartConfig.backGroundColor)
    }

    override fun preDrawData(canvas: Canvas) {
    }

    override fun drawData(canvas: Canvas) {

        labelPaint.textSize = chartConfig.labelTextSize
        labelPaint.color = chartConfig.labelTextColor
        labelPaint.getFontMetrics(tmpFontMetrics)

        when (chartConfig.type) {
            is TimeBarConfig.Type.Day -> drawLabelOfDayType(canvas)
            is TimeBarConfig.Type.FiveDays -> drawLabelOfFiveDaysType(canvas)
            is TimeBarConfig.Type.Week -> drawLabelOfWeekType(canvas)
            is TimeBarConfig.Type.Month -> drawLabelOfMonthType(canvas)
            is TimeBarConfig.Type.Quarter -> drawLabelOfQuarterType(canvas)
            is TimeBarConfig.Type.Year -> drawLabelOfYearType(canvas)
            is TimeBarConfig.Type.FiveYears -> drawLabelOfFiveYearsType(canvas)
            is TimeBarConfig.Type.YTD -> drawLabelOfYTDType(canvas)
            is TimeBarConfig.Type.OneMinute -> drawLabelOfOneMinuteType(canvas)
            is TimeBarConfig.Type.FiveMinutes -> drawLabelOfFiveMinutesType(canvas)
            is TimeBarConfig.Type.SixtyMinutes -> drawLabelOfSixtyMinutesType(canvas)
            is TimeBarConfig.Type.DayTime -> drawLabelOfDayTimeType(canvas)
        }
    }

    override fun preDrawHighlight(canvas: Canvas) {
    }

    override fun drawHighlight(canvas: Canvas) {

        highlightLabelPaint.textSize = chartConfig.highlightLabelTextSize
        highlightLabelPaint.color = chartConfig.highlightLabelTextColor
        highlightLabelPaint.getFontMetrics(tmpFontMetrics)
        highlightLabelBgPaint.color = chartConfig.highlightLabelBgColor
        drawHighlightLabel(canvas)
    }

    override fun drawAddition(canvas: Canvas) {
    }

    private fun drawLabelOfDayType(canvas: Canvas) {

        var lastDrawRight = getChartMainDisplayArea().left
        var lastDrawLabel = ""
        val labelMinSpace = DimensionUtil.dp2px(context, 50f)

        getKEntities().forEachIndexed { idx, kEntity ->

            if (kEntity.containFlag(FLAG_EMPTY)) return@forEachIndexed

            val time = kEntity.getTime()
            tmpDate.time = time
            val label = chartConfig.type.labelDateFormat.format(tmpDate)
            if (label == lastDrawLabel) {
                return@forEachIndexed
            }

            val labelWidth = labelPaint.measureText(label)
            val labelHalfWidth = labelWidth / 2

            tmp2FloatArray[0] = idx + 0.5f
            tmp2FloatArray[1] = 0f
            mapPointsValue2Real(tmp2FloatArray)
            val centerRealX = tmp2FloatArray[0]
            if (centerReal


elseif ufcp_time > allow_erase_at then
                    local radio = GetDevice(devices["VUHF2_RADIO"])
                    -- Confirm ERASE
                    for i = 1,ufcp_com2_max_channel+1 do radio:set_channel_frequency(i,118 * 1e6) end
                    for i = 1,ufcp_com2_max_channel+1 do ufcp_com2_nets1[i] = 0 end
                    for i = 1,ufcp_com2_max_channel+1 do ufcp_com2_nets2[i] = 0 end
                    for i = 1,ufcp_com2_max_channel+1 do ufcp_com2_eccms1[i] = 1 end
                    for i = 1,ufcp_com2_max_channel+1 do ufcp_com2_eccms2[i] = 1 end

                    if radio:get_channel_mode() then
                        ufcp_com2_select_channel(radio:get_channel())
                        radio:set_channel(radio:get_channel())
                    end
                    ufcp_com2_erase = false
                    allow_erase_at = -1.0
                    cancel_erase_at = -1.0
                end
            end
        end
    end

    -- Increase/Decrease field
    if ufcp_sel_format == UFCP_FORMAT_IDS.COM2 then
        if command == device_commands.UFCP_UP and value == 1 then
            local radio = GetDevice(devices["VUHF2_RADIO"])
            if (sel == SEL_IDS.CHANNEL or sel == SEL_IDS.PRST_FREQUENCY) and ufcp_edit_pos == 0 and radio:is_channel_in_range(radio:get_channel() + 1) then
                if radio:get_channel_mode() then
                    radio:set_channel(radio:get_channel() + 1)
                    ufcp_com2_select_channel(radio:get_channel())
                else
                    local freq = radio:get_frequency()
                    radio:set_channel(radio:get_channel() + 1)
                    ufcp_com2_select_channel(radio:get_channel())
                    radio:set_frequency(freq)
                end
            end
        elseif command == device_commands.UFCP_DOWN and value == 1 then
            local radio = GetDevice(devices["VUHF2_RADIO"])
            if (sel == SEL_IDS.CHANNEL or sel == SEL_IDS.PRST_FREQUENCY) and ufcp_edit_pos == 0 and radio:get_channel() > 0 then
                if radio:get_channel_mode() then
                    radio:set_channel(radio:get_channel() - 1)
                    ufcp_com2_select_channel(radio:get_channel())
                else
                    local freq = radio:get_frequency()
                    radio:set_channel(radio:get_channel() - 1)
                    ufcp_com2_select_channel(radio:get_channel())
                    radio:set_frequency(freq)
                end
                end
        end
    elseif ufcp_sel_format == UFCP_FORMAT_IDS.COM2_NET then

    end

    -- Keypad
    if sel == SEL_IDS.MAN_FREQUENCY or sel == SEL_IDS.CHANNEL or sel == SEL_IDS.PRST_FREQUENCY or sel == SEL_IDS.NEXT_FREQUENCY then
        if command == device_commands.UFCP_1 and value == 1 then
            ufcp_continue_edit("1", FIELD_INFO[sel


#!/usr/bin/python
# -*- coding: utf-8 -*-
# vim: ts=4:et:sw=4:

# ----------------------------------------------------------------------
# Copyleft (K), Jose M. Rodriguez-Rosa (a.k.a. Boriel)
#
# This program is Free Software and is released under the terms of
#                    the GNU General License
# ----------------------------------------------------------------------

import src.api.global_ as gl
from .symbol_ import Symbol

# ----------------------------------------------------------------------
# CONST Symbol object
# ----------------------------------------------------------------------

class SymbolCONST(Symbol):
    """ Defines a constant expression (not numerical, e.g. a Label or a @label,
    or a more complex one like @label + 5)
    """
    def __init__(self, expr, lineno):
        super(SymbolCONST, self).__init__(expr)
        self.lineno = lineno
        self._t = gl.optemps.new_t()

    @property
    def expr(self):
        return self.children[0]

    @expr.setter
    def expr(self, value):
        assert isinstance(value, Symbol)
        self.children = [value]

    @property
    def type_(self):
        return self.expr.type_

    def __str__(self):
        return str(self.expr)

    def __repr__(self):
        return str(self)

    @property
    def t(self):
        return self._t

    @t.setter
    def t(self, value):
        self._t = value


--[[
 Copyright 2018 The Nakama Authors

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
--]]

local nk = require("nakama")

--[[
Called when the matchmaker has found a match for some set of users.

Context represents information about the match and server, for information purposes. Format:
{
  env = {}, -- key-value data set in the runtime.env server configuration.
  execution_mode = "Matchmaker",
}

Matchmaker users will contain a table array of the users that have matched together and their prope


db/html/index.html

## Automatic Reference Counting (ARC) or Manual Memory Management?
You can use either style in your Cocoa project.  FMDB will figure out which you are using at compile time and do the right thing.

## What's New in FMDB 2.7

FMDB 2.7 attempts to support a more natural interface. This represents a fairly significant change for Swift developers (audited for nullability; shifted to properties in external interfaces where possible rather than methods; etc.). For Objective-C developers, this should be a fairly seamless transition (unless you were using the ivars that were previously exposed in the public interface, which you shouldn't have been doing, anyway!).

### Nullability and Swift Optionals

FMDB 2.7 is largely the same as prior versions, but has been audited for nullability. For Objective-C users, this simply means that if you perform a static analysis of your FMDB-based project, you may receive more meaningful warnings as you review your project, but there are likely to be few, if any, changes necessary in your code.

For Swift users, this nullability audit results in changes that are not entirely backward compatible with FMDB 2.6, but is a little more Swifty. Before FMDB was audited for nullability, Swift was forced to defensively assume that variables were optional, but the library now more accurately knows which properties and method parameters are optional, and which are not.

This means, though, that Swift code written for FMDB 2.7 may require changes. For example, consider the following Swift 3/Swift 4 code for FMDB 2.6:

```swift
queue.inTransaction { db, rollback in
    do {
        guard let db == db else {
            // handle error here
            return
        }

        try db.executeUpdate("INSERT INTO foo (bar) VALUES (?)", values: [1])
        try db.executeUpdate("INSERT INTO foo (bar) VALUES (?)", values: [2])
    } catch {
        rollback?.pointee = true
    }
}
```

Because FMDB 2.6 was not audited for nullability, Swift inferred that `db` and `rollback` were optionals. But, now, in FMDB 2.7, Swift now knows that, for example, neither `db` nor `rollback` above can be `nil`, so they are no longer optionals. Thus it becomes:

```swift
queue.inTransaction { db, rollback in
    do {
        try db.executeUpdate("INSERT INTO foo (bar) VALUES (?)", values: [1])
        try db.executeUpdate("INSERT INTO foo (bar) VALUES (?)", values: [2])
    } catch {
        rollback.pointee = true
    }
}
```

### Custom Functions

In the past, when writing custom functions, you would have to generally include your own `@autoreleasepool` block to avoid problems when writing functions that scanned through a large table. Now, FMDB will automatically wrap it in an autorelease pool, so you don't have to.

Also, in the past, when retrieving the values passed to the function, you had to drop down to the SQLite C API and include your own `sqlite3_value_XXX` calls. There are now `FMDatabase` methods, `valueInt`, `valueString`, etc., so you can stay within Swift and/or Objective-C, without needing to call the C functions yourself. Likewise, when specifying the return values, you no longer need to call `sqlite3_result_XXX` C API, but rather you can use `FMDatabase` methods, `resultInt`, `resultString`, etc. There is a new `enum` for `valueType` called `SqliteValueType`, which can be used for checking the type of parameter passed to the custom function.

Thus, you can do something like (as of Swift 3):

```swift
db.makeFunctionNamed("RemoveDiacritics", arguments: 1) { context, argc, argv in
    guard db.valueType(argv[0]) == .text || db.valueType(argv[0]) == .null else {
        db.resultError("Expected string parameter", context: context)
        return
    }

    if let string = db.valueString(argv[0])?.folding(options: .diacriticInsensitive, locale: ni


"""Custom HTTP views for Solace Agent Mesh integration."""
from .hello_world import HelloWorldView

# List all views to be exposed
VIEWS = [
    HelloWorldView,
    # Add other view classes here
]


()
   *     ctx.draw()
   *     ```
   */
  stroke(): void
  /**
   *
   * **定义：**
   *
   * 开始创建一个路径，需要调用fill或者stroke才会使用路径进行填充或描边。
   *
   * **Tip**: 在最开始的时候相当于调用了一次 `beginPath()`。
   *
   * **Tip**: 同一个路径内的多次`setFillStyle()`、`setStrokeStyle()`、`setLineWidth()`等设置，以最后一次设置为准。
   *
   * **例子：**
   *
   *     ```javascript
   *     const ctx = wx.createCanvasContext('myCanvas')
   *     // begin path
   *     ctx.rect(10, 10, 100, 30)
   *     ctx.setFillStyle('yellow')
   *     ctx.fill()
   *
   *     // begin another path
   *     ctx.beginPath()
   *     ctx.rect(10, 40, 100, 30)
   *
   *     // only fill this rect, not in current path
   *     ctx.setFillStyle('blue')
   *     ctx.fillRect(10, 70, 100, 30)
   *
   *     ctx.rect(10, 100, 100, 30)
   *
   *     // it will fill current path
   *     ctx.setFillStyle('red')
   *     ctx.fill()
   *     ctx.draw()
   *     ```
   */
  beginPath(): void
  /**
   *
   * **定义：**
   *
   * 关闭一个路径
   *
   * **Tip**: 关闭路径会连接起点和终点。
   *
   * **Tip**: 如果关闭路径后没有调用 `fill()` 或者 `stroke()` 并开启了新的路径，那之前的路径将不会被渲染。
   *
   * **例子：**
   *
   *     ```javascript
   *     const ctx = wx.createCanvasContext('myCanvas')
   *     ctx.moveTo(10, 10)
   *     ctx.lineTo(100, 10)
   *     ctx.lineTo(100, 100)
   *     ctx.closePath()
   *     ctx.stroke()
   *     ctx.draw()
   *     ```
   *
   * **例子：**
   *
   *     ```javascript
   *     const ctx = wx.createCanvasContext('myCanvas')
   *     // begin path
   *     ctx.rect(10, 10, 100, 30)
   *     ctx.closePath()
   *
   *     // begin another path
   *     ctx.beginPath()
   *     ctx.rect(10, 40, 100, 30)
   *
   *     // only fill this rect, not in current path
   *     ctx.setFillStyle('blue')
   *     ctx.fillRect(10, 70, 100, 30)
   *
   *     ctx.rect(10, 100, 100, 30)
   *
   *     // it will fill current path
   *     ctx.setFillStyle('red')
   *     ctx.fill()
   *     ctx.draw()
   *     ```
   */
  closePath(): void
  /**
   *
   * **定义：**
   *
   * 把路径移动到画布中的指定点，不创建线条。
   *
   * **Tip**: 用 `stroke()` 方法来画线条
   *
   * **参数：**
   *
   *   参数 |  类型     |  说明
   * -------|-----------|-------------
   *   x    |  Number   |目标位置的x坐标
   *   y    |  Number   |目标位置的y坐标
   *
   * **示例代码：**
   *
   *     ```javascript
   *     const ctx = wx.cre


 traverse = function traverse(_ref5) {
        var node = _ref5.node,
            children = _ref5.children;

        var value = getPropsData(node).value;
        if (!children || children.length === 0) {
          targetValueList.push({
            label: getLabel(values[value], valueEntities[value], treeNodeLabelProp),
            value: value
          });
          return;
        }

        children.forEach(function (entity) {
          traverse(entity);
        });
      };

      hierarchyList.forEach(function (entity) {
        traverse(entity);
      });

      return targetValueList;
    }
  }

  return valueList.map(function (wrappedValue) {
    return {
      label: getLabel(wrappedValue, valueEntities[wrappedValue.value], treeNodeLabelProp),
      value: wrappedValue.value
    };
  });
}

/**
 * Use `rc-tree` convertDataToTree to convert treeData to TreeNodes.
 * This will change the label to title value
 */
function processProps(props) {
  var title = props.title,
      label = props.label,
      value = props.value,
      cls = props['class'],
      style = props.style,
      _props$on = props.on,
      on = _props$on === undefined ? {} : _props$on;

  var key = props.key;
  if (!key && (key === undefined || key === null)) {
    key = value;
  }
  var p = {
    props: omit(props, ['on', 'key', 'class', 'className', 'style']),
    on: on,
    'class': cls || props.className,
    style: style,
    key: key
  };
  // Warning user not to use deprecated label prop.
  if (label && !title) {
    if (!warnDeprecatedLabel) {
      warning(false, "'label' in treeData is deprecated. Please use 'title' instead.");
      warnDeprecatedLabel = true;
    }

    p.props.title = label;
  }

  return p;
}

export function convertDataToTree(h, treeData) {
  return vcConvertDataToTree(h, treeData, { processProps: processProps });
}

/**
 * Use `rc-tree` convertTreeToEntities for entities calculation.
 * We have additional entities of `valueEntities`
 */
function initWrapper(wrapper) {
  return _extends({}, wrapper, {
    valueEntities: {}
  });
}

function processEntity(entity, wrapper) {
  var value = getPropsData(entity.node).value;
  entity.value = value;

  // This should be empty, or will get error message.
  var currentEntity = wrapper.valueEntities[value];
  if (currentEntity) {
    warning(false, 'Conflict! value of node \'' + entity.key + '\' (' + value + ') has already used by node \'' + currentEntity.key + '\'.');
  }
  wrapper.valueEntities[value] = entity;
}

export function convertTreeToEntities(treeNodes) {
  return vcConvertTreeToEntities(treeNodes, {
    initWrapper: initWrapper,
    processEntity: processEntity
  });
}

/**
 * https://github.com/ant-design/ant-design/issues/13328
 * We need calculate the half check key when searchValue is set.
 */
// TODO: This logic may better move to rc-tree
export function getHalfCheckedKeys(valueList, valueEntities) {
  var values = {};

  // Fill checked keys
  valueList.forEach(function (_ref6) {
    var value = _ref6.value;

    values[value] = false;
  });

  // Fill half checked keys
  valueList.forEach(function (_ref7) {
    var value = _ref7.value;

    var current = valueEntities[value];

    while (current && current.parent) {
      var parentValue = current.parent.value;
      if (parentValue in values) break;
      values[parentValue] = true;

      current = current.parent;


LE_FLOP_REWARD, XTable.XTableFlopReward, "Id")
    StageFightControlCfg = XTableManager.ReadByIntKey(TABLE_STAGE_FIGHT_CONTROL, XTable.XTableStageFightControl, "Id")
    ActivitySortRules = XTableManager.ReadByIntKey(TABLE_ACTIVITY_SORTRULE, XTable.XTableActivitySortRule, "Id")
    local banners = XTableManager.ReadByIntKey(TABLE_CHALLENGE_BANNER, XTable.XTableFubenChallengeBanner, "Id")

    for k, v in pairs(banners) do
        FubenChallengeBanners[v.Type] = v
    end
end

function XFubenConfigs.GetStageCfg()
    return StageCfg
end

function XFubenConfigs.GetStageLevelControlCfg()
    return StageLevelControlCfg
end

function XFubenConfigs.GetStageMultiplayerLevelControlCfg()
    return StageMultiplayerLevelControlCfg
end

function XFubenConfigs.GetStageTransformCfg()
    return StageTransformCfg
end

function XFubenConfigs.GetFlopRewardTemplates()
    return FlopRewardTemplates
end

function XFubenConfigs.GetActivitySortRules()
    return ActivitySortRules
end

function XFubenConfigs.GetActivityPriorityByActivityIdAndType(activityId,type)
    for k,v in pairs(ActivitySortRules) do
        if v.ActivityId == activityId and v.Type == type then
            return v.Priority
        end
    end
    return 0
end

function XFubenConfigs.GetStageFightControl(id)
    for k, v in pairs(StageFightControlCfg) do
        if v.Id == id then
            return v
        end
    end
    return nil
end

function XFubenConfigs.IsKeepPlayingStory(stageId)
    local targetCfg = StageCfg[stageId]
    if not targetCfg or not targetCfg.KeepPlayingStory then
        return false
    end
    return targetCfg.KeepPlayingStory == 1
end

function XFubenConfigs.GetChapterBannerByType(bannerType)
    return FubenChallengeBanners[bannerType] or {}
end


ield on success, or NULL on failure.
//
// Returns a new reference.
PyObject* FindEnumTypeByName(PyDescriptorPool* self, PyObject* arg);

// Looks up a oneof by name. Returns a COneofDescriptor corresponding
// to the oneof on success, or NULL on failure.
//
// Returns a new reference.
PyObject* FindOneofByName(PyDescriptorPool* self, PyObject* arg);

}  // namespace cdescriptor_pool

// Retrieve the global descriptor pool owned by the _message module.
// This is the one used by pb2.py generated modules.
// Returns a *borrowed* reference.
// "Default" pool used to register messages from _pb2.py modules.
PyDescriptorPool* GetDefaultDescriptorPool();

// Retrieve the python descriptor pool owning a C++ descriptor pool.
// Returns a *borrowed* reference.
PyDescriptorPool* GetDescriptorPool_FromPool(const DescriptorPool* pool);

// Initialize objects used by this module.
bool InitDescriptorPool();

}  // namespace python
}  // namespace protobuf

}  // namespace google
#endif  // GOOGLE_PROTOBUF_PYTHON_CPP_DESCRIPTOR_POOL_H__


omJson(jsonDados['compraTipoPedido']);
		fornecedor = jsonDados['fornecedor'] == null ? null : Fornecedor.fromJson(jsonDados['fornecedor']);
		colaborador = jsonDados['colaborador'] == null ? null : Colaborador.fromJson(jsonDados['colaborador']);
		listaCompraPedidoDetalhe = (jsonDados['listaCompraPedidoDetalhe'] as Iterable?)?.map((m) => CompraPedidoDetalhe.fromJson(m)).toList() ?? [];
	}

	Map<String, dynamic> get toJson {
		Map<String, dynamic> jsonDados = <String, dynamic>{};

		jsonDados['id'] = id ?? 0;
		jsonDados['idCompraTipoPedido'] = idCompraTipoPedido ?? 0;
		jsonDados['idFornecedor'] = idFornecedor ?? 0;
		jsonDados['idColaborador'] = idColaborador ?? 0;
		jsonDados['dataPedido'] = dataPedido != null ? DateFormat('yyyy-MM-ddT00:00:00').format(dataPedido!) : null;
		jsonDados['dataPrevistaEntrega'] = dataPrevistaEntrega != null ? DateFormat('yyyy-MM-ddT00:00:00').format(dataPrevistaEntrega!) : null;
		jsonDados['dataPrevisaoPagamento'] = dataPrevisaoPagamento != null ? DateFormat('yyyy-MM-ddT00:00:00').format(dataPrevisaoPagamento!) : null;
		jsonDados['localEntrega'] = localEntrega;
		jsonDados['localCobranca'] = localCobranca;
		jsonDados['contato'] = contato;
		jsonDados['valorSubtotal'] = valorSubtotal;
		jsonDados['taxaDesconto'] = taxaDesconto;
		jsonDados['valorDesconto'] = valorDesconto;
		jsonDados['valorTotal'] = valorTotal;
		jsonDados['tipoFrete'] = setTipoFrete(tipoFrete);
		jsonDados['formaPagamento'] = setFormaPagamento(formaPagamento);
		jsonDados['baseCalculoIcms'] = baseCalculoIcms;
		jsonDados['valorIcms'] = valorIcms;
		jsonDados['baseCalculoIcmsSt'] = baseCalculoIcmsSt;
		jsonDados['valorIcmsSt'] = valorIcmsSt;
		jsonDados['valorTotalProdutos'] = valorTotalProdutos;
		jsonDados['valorFrete'] = valorFrete;
		jsonDados['valorSeguro'] = valorSeguro;
		jsonDados['valorOutrasDespesas'] = valorOutrasDespesas;
		jsonDados['valorIpi'] = valorIpi;
		jsonDados['valorTotalNf'] = valorTotalNf;
		jsonDados['quantidadeParcelas'] = quantidadeParcelas ?? 0;
		jsonDados['diaPrimeiroVencimento'] = Biblioteca.removerMascara(diaPrimeiroVencimento);
		jsonDados['intervaloEntreParcelas'] = intervaloEntreParcelas ?? 0;
		jsonDados['diaFixoParcela'] = Biblioteca.removerMascara(diaFixoParcela);
		jsonDados['codigoCotacao'] = codigoCotacao;
		jsonDados['compraTipoPedido'] = compraTipoPedido == null ? null : compraTipoPedido!.toJson;
		jsonDados['fornecedor'] = fornecedor == null ? null : fornecedor!.toJson;
		jsonDados['colaborador'] = colaborador == null ? null : colaborador!.toJson;

		var listaCompraPedidoDetalheLocal = [];
		for (CompraPedidoDetalhe objeto in listaCompraPedidoDetalhe


te', (iterable,)),
            ('compress', (iterable, ())),
            ('combinations', (iterable, 1)),
            ('combinations_with_replacement', (iterable, 1)),
    ):
        func = getattr(itertools, func)

        result = func(*args)
        if func == itertools.tee:
            result = result[0]
        tresult = type(result)
        if tresult not in _default_checkers:
            _default_checkers[tresult] = _iteratorChecker

_fixup_itertools()
del _fixup_itertools

def _clear():
    _checkers.clear()
    _checkers.update(_default_checkers)
    _checkers.update(BasicTypes)

_clear()

try:
    from zope.testing.cleanup import addCleanUp
except ImportError:  # pragma: no cover
    pass
else:
    addCleanUp(_clear)


SetCVar("trackerFilter", WATCHFRAME_FILTER_TYPE);
	WatchFrame_Update();
end

function WatchFrame_GetVisibleIndex(questLogIndex)
	for i = 1, #VISIBLE_WATCHES do
		if ( VISIBLE_WATCHES[i] == questLogIndex ) then
			return i;
		end
	end
end

function WatchFrame_MoveQuest(button, questLogIndex, numMoves)
	if ( WATCHFRAME_SORT_TYPE ~= WATCHFRAME_SORT_MANUAL ) then
		WatchFrame_SetSorting(nil, WATCHFRAME_SORT_MANUAL);
		UIErrorsFrame:AddMessage(TRACKER_SORT_MANUAL_WARNING, 1.0, 1.0, 0.0, 1.0);
	end
	local numVisibleWatches = #VISIBLE_WATCHES;
	local indexStart = WatchFrame_GetVisibleIndex(questLogIndex);
	local indexEnd = indexStart + numMoves;
	if ( indexEnd < 1 ) then
		indexEnd = 1;
	elseif ( indexEnd > numVisibleWatches ) then
		indexEnd = numVisibleWatches;
	end
	ShiftQuestWatches(GetQuestWatchIndex(questLogIndex), GetQuestWatchIndex(VISIBLE_WATCHES[indexEnd]));
	WatchFrame_Update();
	if ( WorldMapFrame:IsShown() ) then
		WorldMapFrame_UpdateMap();
	end
end

-- AutoQuest pop-ups
local numPopUpFrames = 0;

function WatchFrameAutoQuest_GetOrCreateFrame(parent, index)
	if (_G["WatchFrameAutoQuestPopUp"..index]) then
		return _G["WatchFrameAutoQuestPopUp"..index];
	end
	local frame = CreateFrame("SCROLLFRAME", "WatchFrameAutoQuestPopUp"..index, parent, "WatchFrameAutoQuestPopUpTemplate");
	frame.index = index;
	numPopUpFrames = numPopUpFrames+1;
	return frame;
end

function WatchFrameAutoQuest_DisplayAutoQuestPopUps(lineFrame, nextAnchor, maxHeight, frameWidth)
	local numPopUps = 0;
	local maxWidth = 0;
	local numAutoQuestPopUps = GetNumAutoQuestPopUps();
	for i=1, numAutoQuestPopUps do
		local questID, popUpType = GetAutoQuestPopUp(i);
		local questTitle, level, questTag, suggestedGroup, isHeader, isCollapsed, isComplete, isDaily, _ = GetQuestLogTitle(GetQuestLogIndexByID(questID));

		if ( isComplete and isComplete > 0 ) then
			isComplete = true;
		else
			isComplete = false;
		end

		if (questTitle and questTitle ~= "") then
			local frame = WatchFrameAutoQuest_GetOrCreateFrame(lineFrame, numPopUps+1);
			frame:Show();
			frame:ClearAllPoints();
			frame:SetParent(lineFrame);

			if (not frame.questID) then
				-- Only show the animation for new notifications
				frame.ScrollChild.Flash:Hide();
				WatchFrameAutoQuest_SlideIn(frame, 0.4);
			end

			if (isComplete and popUpType == "COMPLETE") then
				frame.ScrollChild.QuestionMark:Show();
				frame.ScrollChild.Exclamation:Hide();
				frame.ScrollChild.TopText:SetText(QUEST_WATCH_POPUP_CLICK_TO_COMPLETE);
				frame.ScrollChild.BottomText:Hide();
				frame.ScrollChild.TopText:SetPoint("TOP", 0, -12);
				frame.ScrollChild.QuestName:SetPoint("TOP", 0, -32);
				if (frame.questID and frame.type=="OFFER") then
					frame.ScrollChild.Flash:Show();
				end
				frame.type="COMPLETED";
			elseif (popUpType == "OFFER") then
				frame.ScrollChild.QuestionMark:Hide();
				frame.ScrollChild.Exclamation:Show();
				frame.ScrollChild.TopText:SetText(QUEST_WATCH_POPU


text was added by using code", missing);
            newTask.Start = DateTime.Now;
            newTask.Duration = "3";
            newTask.ResourceNames = "Rob Caron, Kelly Krout";
        }
        //</Snippet1>

        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
        }

        #region VSTO generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }

        #endregion
    }
}


(r11)
	mtctr r12
	bctr
	.section	__DATA,__la_symbol_ptr,lazy_symbol_pointers
L_puts$lazy_ptr:
	.indirect_symbol	_puts
	.long	dyld_stub_binding_helper

.subsections_via_symbols
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ; @.str
	.asciz	 "Hello, world!"

; DARWIN-G4-DUMP:Format: Mach-O 32-bit ppc
; DARWIN-G4-DUMP:Arch: powerpc
; DARWIN-G4-DUMP:AddressSize: 32bit
; DARWIN-G4-DUMP:Relocations [
; DARWIN-G4-DUMP:  Section __text {
; DARWIN-G4-DUMP:    0x34 1 2 0 PPC_RELOC_BR24 0 0x3
; DARWIN-G4-DUMP:    0x30 0 2 n/a PPC_RELOC_LO16_SECTDIFF 1 0x74
; DARWIN-G4-DUMP:    0x0 0 2 n/a PPC_RELOC_PAIR 1 0x14
; DARWIN-G4-DUMP:    0x2C 0 2 n/a PPC_RELOC_HA16_SECTDIFF 1 0x74
; DARWIN-G4-DUMP:    0x60 0 2 n/a PPC_RELOC_PAIR 1 0x14
; DARWIN-G4-DUMP:  }
; DARWIN-G4-DUMP:  Section __picsymbolstub1 {
; DARWIN-G4-DUMP:    0x14 0 2 n/a PPC_RELOC_LO16_SECTDIFF 1 0x70
; DARWIN-G4-DUMP:    0x0 0 2 n/a PPC_RELOC_PAIR 1 0x58
; DARWIN-G4-DUMP:    0xC 0 2 n/a PPC_RELOC_HA16_SECTDIFF 1 0x70
; DARWIN-G4-DUMP:    0x18 0 2 n/a PPC_RELOC_PAIR 1 0x58
; DARWIN-G4-DUMP:  }
; DARWIN-G4-DUMP:  Section __la_symbol_ptr {
; DARWIN-G4-DUMP:    0x0 0 2 1 PPC_RELOC_VANILLA 0 dyld_stub_binding_helper
; DARWIN-G4-DUMP:  }
; DARWIN-G4-DUMP:]


*: [前置条件]
- **操作步骤**:
  1. 用户执行...
  2. 系统显示...
  3. 用户选择...
- **期望结果**: [期望的结果]

### 场景 2: [场景名称]
- **用户角色**: [角色描述]
- **前置条件**: [前置条件]
- **操作步骤**:
  1. 用户执行...
  2. 系统显示...
  3. 用户选择...
- **期望结果**: [期望的结果]

## 🔗 相关功能

这个功能与现有功能的关系：

- **依赖的功能**:
- **影响的功能**:
- **互补的功能**:

## 📈 预期影响

### 积极影响
- **性能提升**: [描述性能改进]
- **用户体验**: [描述UX改进]
- **开发效率**: [描述开发效率提升]

### 潜在风险
- **兼容性**: [向后兼容性考虑]
- **复杂性**: [实现复杂度]
- **维护成本**: [长期维护考虑]

## 🎯 验收标准

这个功能的验收标准是什么？

- [ ] **标准1**: 具体的可测试标准
- [ ] **标准2**: 具体的可测试标准
- [ ] **标准3**: 具体的可测试标准

## 📚 参考资料

提供相关的参考资料：

- **技术文档**: [链接到相关技术文档]
- **竞品分析**: [类似功能在其他产品中的实现]
- **标准规范**: [相关的行业标准或RFC]
- **研究论文**: [相关的研究或最佳实践]

## 🏷 优先级

请选择这个功能的优先级：

- [ ] 🔴 **高优先级** - 对项目核心功能很重要
- [ ] 🟡 **中优先级** - 会改善用户体验
- [ ] 🟢 **低优先级** - 有了更好，没有也可以

## 🎯 目标版本

您希望这个功能在哪个版本中实现？

- [ ] 下一个补丁版本 (v1.x.x)
- [ ] 下一个小版本 (v1.x.0)
- [ ] 下一个大版本 (v2.0.0)
- [ ] 未来某个版本
- [ ] 无特殊要求

## 🤝 贡献意愿

您是否愿意为实现这个功能贡献代码？

- [ ] ✅ 我愿意实现这个功能
- [ ] ⚠ 我需要指导来实现这个功能
- [ ] ❌ 我无法实现这个功能，但愿意测试
- [ ] 💬 我只是提出建议

## ✅ 检查清单

请确认您已经完成以下检查：

- [ ] 我已经搜索了现有的 Issues，确认这不是重复请求
- [ ]


;
  @SerializedName("thumbnail_source")
  private String mThumbnailSource = null;
  @SerializedName("thumbnail_url")
  private String mThumbnailUrl = null;
  @SerializedName("url")
  private String mUrl = null;
  @SerializedName("url_tags")
  private String mUrlTags = null;
  @SerializedName("video_id")
  private String mVideoId = null;
  @SerializedName("video_name")
  private String mVideoName = null;
  protected static Gson gson = null;

  public AdAssetVideo() {
  }

  public String getId() {
    return getFieldId().toString();
  }
  public static AdAssetVideo loadJSON(String json, APIContext context, String header) {
    AdAssetVideo adAssetVideo = getGson().fromJson(json, AdAssetVideo.class);
    if (context.isDebug()) {
      JsonParser parser = new JsonParser();
      JsonElement o1 = parser.parse(json);
      JsonElement o2 = parser.parse(adAssetVideo.toString());
      if (o1.getAsJsonObject().get("__fb_trace_id__") != null) {
        o2.getAsJsonObject().add("__fb_trace_id__", o1.getAsJsonObject().get("__fb_trace_id__"));
      }
      if (!o1.equals(o2)) {
        context.log("[Warning] When parsing response, object is not consistent with JSON:");
        context.log("[JSON]" + o1);
        context.log("[Object]" + o2);
      }
    }
    adAssetVideo.context = context;
    adAssetVideo.rawValue = json;
    adAssetVideo.header = header;
    return adAssetVideo;
  }

  public static APINodeList<AdAssetVideo> parseResponse(String json, APIContext context, APIRequest request, String header) throws MalformedResponseException {
    APINodeList<AdAssetVideo> adAssetVideos = new APINodeList<AdAssetVideo>(request, json, header);
    JsonArray arr;
    JsonObject obj;
    JsonParser parser = new JsonParser();
    Exception exception = null;
    try{
      JsonElement result = parser.parse(json);
      if (result.isJsonArray()) {
        // First, check if it's a pure JSON Array
        arr = result.getAsJsonArray();
        for (int i = 0; i < arr.size(); i++) {
          adAssetVideos.add(loadJSON(arr.get(i).getAsJsonObject().toString(), context, header));
        };
        return adAssetVideos;
      } else if (result.isJsonObject()) {
        obj = result.getAsJsonObject();
        if (obj.has("data")) {
          if (obj.has("paging")) {
            JsonObject paging = obj.get("paging").getAsJsonObject();
            if (paging.has("cursors")) {
                JsonObject cursors = paging.get("cursors").getAsJsonObject();
                String before = cursors.has("before") ? cursors.get("before").getAsString() : null;
                String after = cursors.has("after") ? cursors.get("after").getAsString() : null;
                adAssetVideos.setCursors(before, after);
            }
            String previous = paging.has("previous") ? paging.get("previous").getAsString() : null;
            String next = paging.has("next") ? paging.get("next").getAsString() : null;
            adAssetVideos.setPaging(previous, next);
            if (context.hasAppSecret()) {
              adAssetVideos.setAppSecret(context.getAppSecretProof());
            }
          }
          if (obj.get("data").isJsonArray()) {
            // Second, check if it's a JSON array with "data"
            arr = obj.get("data").getAsJsonArray();
            for (int i = 0; i < arr.size(); i++) {
              adAssetVideos.add(loadJSON(arr.get(i).getAsJsonObject().toString(), context, header));
            };
          } else if (obj.get("data


switch (left) {
            case 7:
                b |= (long) input.get(position + len + 6) << 48;
            case 6:
                b |= (long) input.get(position + len + 5) << 40;
            case 5:
                b |= (long) input.get(position + len + 4) << 32;
            case 4:
                b |= (long) input.get(position + len + 3) << 24;
            case 3:
                b |= (long) input.get(position + len + 2) << 16;
            case 2:
                b |= (long) input.get(position + len + 1) << 8;
            case 1:
                b |= input.get(position + len);
                break;
            case 0:
                break;
            default:
                throw new IllegalStateException("Unexpected value: " + left);
        }

        v3 ^= b;
        for (int i = 0; i < compressionRounds; i++) {
            sipround();
        }

        v0 ^= b;
        v2 ^= 0xFF;
        for (int i = 0; i < finalizationRounds; i++) {
            sipround();
        }

        return v0 ^ v1 ^ v2 ^ v3;
    }

    private void sipround() {
        v0 += v1;
        v2 += v3;
        v1 = Long.rotateLeft(v1, 13);
        v3 = Long.rotateLeft(v3, 16);
        v1 ^= v0;
        v3 ^= v2;

        v0 = Long.rotateLeft(v0, 32);

        v2 += v1;
        v0 += v3;
        v1 = Long.rotateLeft(v1, 17);
        v3 = Long.rotateLeft(v3, 21);
        v1 ^= v2;
        v3 ^= v0;

        v2 = Long.rotateLeft(v2, 32);
    }
}
/*
 * Copyright 2022 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.netty.handler.codec.quic;

import javax.net.ssl.SSLEngine;

/**
 * Allow to log keys, logging keys are following
 *
 *     NSS Key Log Format. This is intended for debugging use with tools like Wireshark.
 */
public interface BoringSSLKeylog {

    /**
     * Called when a key should be logged.
     *
     * @param engine    the engine.
     * @param key       the key.
     */
    void logKey(SSLEngine engine, String key);
}
/*
 * Copyright 2021 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.netty.handler.codec.quic;

import io.netty.buffer.ByteBuf;
import io.netty.channel.epoll.SegmentedDatagramPacket;
import io.netty.channel.socket.DatagramPacket;
import io.netty.util.internal.ObjectUtil;

import java.net.InetSocketAddress;

/**
 * Class that provides utility methods to setup {@code QUIC} when using the {@code EPOLL} transport.
 */
publi


}
            );

            // # Handle the special "help" command

            var helpAliases = new HashSet<string> { "help", "--help", "-help", "/help", "-h", "/h" };
            if (args.Length == 0 || args.Any(arg => helpAliases.Contains(arg)))
            {
                Console.WriteLine(Cli.GenerateUsageMessage(cmdLine));
                return 0;
            }

            // # Parse

            var parsing = Cli.ParseIn


>The mesh containing the vertices.</param>
        /// <param name="index">The vertices index to find the distances to.</param>
        /// <param name="distances">The distances for each vertex in the mesh.
        /// This will improve the results for meshes that have bad triangle quality.</param>
        /// <returns>The maximum distance value.</returns>
        public double EstimateGeodesicDistances(Polyhedron3<K> mesh, int index, List<double> distances)
        {
            CheckIsValidTriangleException(mesh);

            int count = Kernel.EstimateGeodesicDistances_PH(Ptr, mesh.Ptr, index, false);

            double max = GetDistances(count, distances);
            ClearDistances();

            return max;
        }

    }

    public abstract class HeatMethod : PolyhedraAlgorithm
    {
        /// <summary>
        ///
        /// </summary>
        private HeatMethod()
        {

        }

        /// <summary>
        /// Create a new instance.
        /// </summary>
        /// <param name="kernel"></param>
        internal HeatMethod(CGALKernel kernel)
        {
            Kernel = kernel.HeatMethodKernel;
            Ptr = Kernel.Create();
        }

        /// <summary>
        /// Create a new instance from a existing pointer to a unmanaged object.
        /// </summary>
        /// <param name="kernel"></param>
        /// <param name="ptr">The unmanaged objects pointer.</param>
        internal HeatMethod(CGALKernel kernel, IntPtr ptr) : base(ptr)
        {
            Kernel = kernel.HeatMethodKernel;
            Ptr = ptr;
        }

        /// <summary>
        ///
        /// </summary>
        internal HeatMethodKernel Kernel { get; private set; }

        /// <summary>
        ///
        /// </summary>
        /// <param name="count"></param>
        /// <param name="distances"></param>
        /// <returns></returns>
        protected double GetDistances(int count, List<double> distances)
        {
            double max = double.NegativeInfinity;
            for (int i = 0; i < count; i++)
            {
                var dist = GetDistance(i);

                if (dist > max)
                    max = dist;

                distances.Add(dist);
            }

            return max;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        protected double GetDistance(int index)
        {
            return Kernel.GetDistance(Ptr, index);
        }

        /// <summary>
        ///
        /// </summary>
        protected void ClearDistances()
        {
            Kernel.ClearDistances(Ptr);
        }

        /// <summary>
        ///
        /// </summary>
        protected override void ReleasePtr()
        {
            Kernel.Release(Ptr);
        }

    }

}


 useValueTwo = cells[1].userValue ?: return false

        return if (result != 0) {
            if (useValueOne > useValueTwo) {
                useValueOne == useValueTwo * result
            } else {
                useValueTwo == useValueOne * result
            }
        } else {
            (useValueOne == 0).xor(useValueTwo == 0)
        }
    }

    private fun isSubtractMathsCorrect(): Boolean {
        if (cells.size != 2) {
            return false
        }

        val firstValue = cells[0].userValue ?: return false
        val secondValue = cells[1].userValue ?: return false

        return if (firstValue > secondValue) {
            firstValue - secondValue == result
        } else {
            secondValue - firstValue == result
        }
    }

    fun isMathsCorrect(): Boolean {
        if (cells.size == 1) {
            return cells[0].isUserValueCorrect
        }
        return if (showOperators) {
            when (action) {
                GridCageAction.ACTION_ADD -> isAddMathsCorrect()
                GridCageAction.ACTION_MULTIPLY -> isMultiplyMathsCorrect()
                GridCageAction.ACTION_DIVIDE -> isDivideMathsCorrect()
                GridCageAction.ACTION_SUBTRACT -> isSubtractMathsCorrect()
                GridCageAction.ACTION_NONE -> true
            }
        } else {
            isAddMathsCorrect() ||
                isMultiplyMathsCorrect() ||
                isDivideMathsCorrect() ||
                isSubtractMathsCorrect()
        }
    }

    fun isUserMathCorrect(): Boolean =
        if (cells.any { !it.isUserValueSet }) {
            true
        } else {
            isMathsCorrect()
        }

    fun addCell(cell: GridCell) {
        cells = cells + cell
        cell.cage = this
    }

    val numberOfCells: Int
        get() = cells.size

    fun getCell(cellNumber: Int): GridCell = cells[cellNumber]

    fun cageText(): String =
        if (showOperators) {
            result.toString() + action.operationDisplayName
        } else {
            result.toString()
        }

    fun satisfiesConstraints(possibleNumbers: IntArray): Boolean = cageType.satisfiesConstraints(possibleNumbers)

    companion object {
        fun createWithCells(
            id: Int,
            grid: Grid,
            action: GridCageAction,
            firstCell: GridCell,
            cageType: GridCageType,
        ): GridCage {
            val cage = GridCage(id, grid.options.showOperators, action, cageType)
            for (coordinate in cageType.coordinates) {
                val col = firstCell.column + coordinate.first
                val row = firstCell.row + coordinate.second
                cage.addCell(grid.getValidCellAt(row, col))
            }
            return cage
        }

        fun createWithSingleCellArithmetic(
            id: Int,
            grid: Grid,
            gridCell: GridCell,
        ): GridCage {
            val cage = GridCage(id, grid.options.showOperators, GridCageAction.ACTION_NONE, GridCageType.SINGLE)
            cage.result = gridCell.value
            cage.addCell(gridCell)

            return cage
        }
    }

    override fun toString(): String = "GridCage id=$id"
}
package org.piepmeyer.gauguin.game.save

import org.koin.core.component.KoinComponent
import org.piepmeyer.gauguin.grid.Grid
import java.io.File

class SavedGamesService(
    private val filesDir: File,
) : KoinComponent {
    private var listeners = mutableListOf<SavedGamesListener>()

    fun savedGameFiles(): List<


ee = bob2)
        val (alice3, bob3) = nodes2
        val (nodes3, preimage_bob2alice_1, _) = addHtlc(50_000_000.msat, payer = bob3, payee = alice3)
        val (bob4, alice4) = nodes3
        val (nodes4, _, _) = addHtlc(55_000_000.msat, payer = bob4, payee = alice4)
        val (bob5, alice5) = nodes4
        val (alice6, bob6) = crossSign(alice5, bob5)
        val (alice7, bob7) = fulfillHtlc(1, preimage_alice2bob_2, payer = alice6, payee = bob6)
        val (bob8, alice8) = fulfillHtlc(0, preimage_bob2alice_1, payer = bob7, payee = alice7)
        assertIs<LNChannel<Normal>>(alice8)
        assertIs<LNChannel<Normal>>(bob8)

        // at this point here is the situation from alice pov and what she should do when bob publishes his commit tx:
        // balances :
        //    alice's balance : 449 999 990                             => nothing to do
        //    bob's balance   :  95 000 000                             => nothing to do
        // htlcs :
        //    alice -> bob    : 250 000 000 (bob does not have the preimage)   => wait for the timeout and spend
        //    alice -> bob    : 100 000 000 (bob has the preimage)             => if bob does not use the preimage, wait for the timeout and spend
        //    alice -> bob    :      10 000 (dust)                             => won't appear in the commitment tx
        //    bob -> alice    :  50 000 000 (alice has the preimage)           => spend immediately using the preimage
        //    bob -> alice    :  55 000 000 (alice does not have the preimage) => nothing to do, bob will get his money back after the timeout

        val bobCommitTx = bob8.signCommitTx()
        assertEquals(8, bobCommitTx.txOut.size) // 2 main outputs, 4 pending htlcs and 2 anchors

        val (aliceClosing, actions) = alice8.process(ChannelCommand.WatchReceived(WatchSpentTriggered(alice8.channelId, WatchSpent.ChannelSpent(TestConstants.fundingAmount), bobCommitTx)))
        assertIs<LNChannel<Closing>>(aliceClosing)
        assertTrue(actions.isNotEmpty())

        // in response to that, alice publishes its claim txs
        // in addition to its main output, alice can only claim 3 out of 4 htlcs,
        // she can't do anything regarding the htlc sent by bob for which she does not have the preimage
        val mainTx = actions.hasPublishTx(Type.ClaimRemoteDelayedOutputTx)
        val htlcSuccessTxs = actions.findPublishTxs(Type.ClaimHtlcSuccessTx)
        assertEquals(1, htlcSuccessTxs.size)
        val htlcTimeoutTxs = actions.findPublishTxs(Type.ClaimHtlcTimeoutTx)
        assertEquals(2, htlcTimeoutTxs.size)
        val amountClaimed = (listOf(mainTx) + htlcSuccessTxs + htlcTimeoutTxs).map { claimTx ->
            assertEquals(1, claimTx.txIn.size)
            assertEquals(1, claimTx.txOut.size)
            Transaction.correctlySpends(claimTx, listOf(bobCommitTx), ScriptFlags.STANDARD_SCRIPT_VERIFY_FLAGS)
            claimTx.txOut[0].amount
        }.sum()
        // at best we have a little less than 500 000 + 250 000 + 100 000 + 50 000 = 900 000 (because fees)
        assertEquals(880_880.sat, amountClaimed)

        val rcp = aliceClosing.state.remoteCommitP


) * 0.5f + 0.5f));
                logoHeight += logoHeight % 2;

                spriteBatch.Draw(_spriteLogo0.Texture,
                    new Rectangle((int)_logoPosition.X, (int)_logoPosition.Y + _spriteLogo0.SourceRectangle.Height / 2 - logoHeight / 2,
                    _spriteLogo0.SourceRectangle.Width, logoHeight), _spriteLogo0.ScaledRectangle, Color.White);

                var textTransparency = Math.Clamp((_logoState - 0.5f) * 2, 0, 1);
                DrawHelper.DrawNormalized(spriteBatch, _spriteLogo1, _logoPosition, Color.White * textTransparency);
            }


4.spines['right'].set_visible(False)
    ax4.spines['top'].set_visible(False)
    ax4.set_title('(c) NeFT${_{3\%}}$+Reversed${_{x\%}}$ $\Delta$Rank with NeFT${_{3\%}}$+Reversed${_{9\%}}$', size=15)

    # fig_path = 'different_type_neuron_1.pdf'
    # plt.savefig(fig_path)
    # plt.subplots_adjust(left=0.01, right=0.99, top=0.90, bottom=0.05)
    plt.tight_layout()
    ax1.grid(None)
    ax2.grid(None)
    ax4.grid(None)
    # ax1.legend(handles=[strongly, suppressed, indirectly, strongly_2, suppressed_2, indirectly_2],
    #            labels=['Strongly', 'Suppressed', 'Indirectly',
    #                    'Strongly and\n$\Delta$Rank with NeFT${_{12\%}}$',
    #                    'Suppressed and\n$\Delta$Rank with NeFT${_{12\%}}$',
    #                    'Indirectly and\n$\Delta$Rank with NeFT${_{12\%}}$'], loc='upper center', ncol=3)

    labelss = ax1.legend(handles=[strongly, strongly_2, suppressed, suppressed_2, indirectly, indirectly_2],
                         labels=['Strongly', 'Strongly and\n$\Delta$Rank with NeFT${_{12\%}}$', 'Suppressed',
                                 'Suppressed and\n$\Delta$Rank with NeFT${_{12\%}}$', 'Indirectly',
                                 'Indirectly and\n$\Delta$Rank with NeFT${_{12\%}}$'], ncol=3,
                         bbox_to_anchor=(1, -0.33))

    # labelss.set_fontproperties('Times New Roman')

    fig_path = 'different_type_neuron_all_2.pdf'
    plt.savefig(fig_path)
    plt.show()

def run_15():
    plt.rcParams['figure.figsize'] = [5, 5]
    matplotlib.rcParams['pdf.fonttype'] = 42
    matplotlib.rcParams['ps.fonttype'] = 42

    x = ['3%', '4%', '6%', '7%', '9%']
    # y1 = [28.67, 28.71, 28.70, 28.83, 28.40]
    # y2 = [27.59, 27.59, 27.38, 27.22, 27.00]

    # y1_bleu = [28.67, 28.70, 28.69, 28.82, 28.39]
    # y2_bleu = [27.58, 27.59, 27.37, 27.22, 26.99]
    y1 = [81.92, 81.97, 82.27, 82.03, 82.10]
    y2 = [81.47, 81.47, 81.24, 81.07, 80.82]

    fig, ax = plt.subplots()
    ax.spines['right'].set_visible(False)
    ax.spines['top'].set_visible(False)

    plt.rc('font', family='Times New Roman')

    plt.xlabel('Additional Selection Percentage (%)', fontdict={'fontsize': 15, 'family': 'Times New Roman'})  # x轴标题
    plt.ylabel('COMET', fontdict={'fontsize': 15, 'family': 'Times New Roman'})  # y轴标题
    ax.plot(x, y1, marker='o', markersize=3)  # 绘制折线图，添加数据点，设置点的大小
    ax.plot(x, y2, marker='o', markersize=3)

    for a, b in zip(x, y1):
        if b == 81.92:
            ax.text(a, b, b, ha='left', va='bottom', fontsize=15)
        else:
            ax.text(a, b, b, ha='center', va='bottom', fontsize=15)
    flag = 1
    for a, b in zip(x, y2):
        if flag == 1:
            flag = 0
            ax.text(a, b, b, ha='left', va='bottom', fontsize=15)
        else:
            ax.text(a, b, b, ha='center', va='bottom', fontsize=15)

    plt.legend(['NeFT${_{3+x\%}}$', 'NeFT${_{3\%}}$+Reversed${_{x\%}}$'], fontsize=15, loc='center right')  # 设置折线名称
    # plt.grid(None)

    ax.tick_params('x', labelsize=15, direction='out')
    ax.tick_params('y', labelsize=15, direction='in')

    ax.minorticks_off()
    plt.yticks(fontproperties='Times New Roman', size=15)
    plt.xticks(fontproperties='Times New Roman', size=15)
    plt.tight_layout()

    plt.savefig('adding neurons.pdf')
    plt.show()  # 显示折线图

if __name__ == '__main__':
    # neuron_heatmap

    # neuron_heatmap(
    #     path=r'/data5/haoyun.xu/study/MI/MMMI/src/MI/experiment_setup/find_neuron/results/neurons/HS_with_fullparam_after_gen/correlaton_W.enzh_sft_layer4.checkpoint-2500_HS.train_enzh_org.2500steps.after_gen_cos.csv',
    #     vmax=1, threshold=0.4)

    # neuron_heatmap(
    #     path=r'/data5/haoyun.xu/study/MI/MMMI/src/MI/experiment_setup/find_neuron/results/neurons/HS_with_fullparam_after_gen/correlaton_W.enzh_sft_layer0_deepspeed.checkpoint-2500_HS.train_enzh_org.2500steps.after_gen_cos.csv',
    #     vmax=1, threshold=0.4)
    #
    # neuron_heatmap(
    #     path=r'/data5/haoyun.xu/study/MI/MMMI/src/MI/experiment_setup/find_neuron/results/neurons/HS_with_fullparam_after_gen/correlaton_W.enzh_sft_layer1_deepspeed.checkpoint-2500_HS.train_enzh_org.2500steps.after_gen_cos.csv',
    #     vmax=1, threshold=0.4)
    #
    # neuron_heatmap(
    #     path=r'/data5/haoyun.xu/study/MI/MMMI/src/MI/experiment_setup/find_neuron/results/neurons/HS_with_fullparam_after_gen/correlaton_W.enzh_sft_layer2_deepspeed.checkpoint-2500_HS.train_enzh_org.2500steps.after_gen_cos.csv',
    #


 = this.checkWin(this.board);
    this.writeWinner(winner);
        if (this.isGameOver == false) {
          this.onMoveAi(this.player1, this.player2);
        }

    if (winner) {
      this.writeWinner(winner);
    }

  }

  private onMoveAi(player1, player2) {
    if (this.isGameOver) {
      return;
    }
    else {
      const index = this.minMax(this.board, 0, player2);
      this.board[index] = player2;
      const winner = this.checkWin(this.board);
      if (winner) {
        if (winner == 'X'){
          this.xWins++;
          this.winner = 'X';
          this.isGameOver = true;
        }

        else if (winner == 'O'){
          this.oWins++;
          this.winner = 'O';
          this.isGameOver = true;
        }
          this.writeWinner(winner);

      }
    }
  }

  minMax(board: string[], depth: number, player: string) {

    if ((depth <= 3 && depth >= -3) || this.BoardSize == '3') {
      const result = this.checkWin(board);
      if (result) {
        if (result === this.player1) {
          return -100 + depth;
        } else if (result === this.player2) {
          return 100 - depth;
        } else if (result === 'draw') {
          return 0;
        }
      }

      const moves = [];
      board.forEach((v, i) => {
        if (v === null) {
          const newBoard = [...board];
          newBoard[i] = player;
          const score = this.minMax(
            newBoard,
            depth + 1,
            player === this.player1 ? this.player2 : this.player1
          );
          moves.push({
            index: i,
            score: score,
          });
        }
      });

      const minOrMax =
        player === this.player1
          ? Math.min(...moves.map(x => x.score))
          : Math.max(...moves.map(x => x.score));

      const move = moves.find(x => x.score === minOrMax);
      if (depth === 0) {
        return move.index;
      } else {
        return move.score;
      }
    }
    else {
      return this.makeRandomAIMove(this.board);
    }
  }

  checkWin(board: string[]) {
    if (this.BoardSize == '3') {
      return this.checkWin3x3(board);
    }
    else if (this.BoardSize == '4') {
      return this.checkWin4x4(board);
    }
  }

  checkWin3x3(board: string[]) {

    //Rows

    if (board[0] === board[1] && board[0] === board[2] && board[0]) {
      return board[0];
    }
    if (board[3] === board[4] && board[3] === board[5] && board[3]) {
      return  board[3];
    }
    if (board[6] === board[7] && board[6] === board[8] && board[6]) {
      return board[6];
    }

    //Columns

    if (board[0] === board[3] && board[0] === board[6] && board[0]) {
      return  board[0];
    }
    if (board[1] === board[4] && board[1] === board[7] && board[1


 _Profiles_ class.

Some profiles have no friends, and ten profile "communities" are easily identifiable (a "community" is a group of highly connected profiles):

![](../../images/demo-dbs/social-travel-agency/profiles.png)

## Customers' Friends

The graph below shows the relationships between all customers and their friends.

All customer vertices are connected to their corresponding profiles in the social platform. The profiles may have friends, or not.

![](../../images/demo-dbs/social-travel-agency/customers_friends.png)

## Customer-Country Relationship

The graph below shows the relationships between all customers and their countries of origin:

![](../../images/demo-dbs/social-travel-agency/customers_countries.png)

## Customer-Restaurant Relationship

Relationships between customers and restaurants are reported in the graph below:

![](../../images/demo-dbs/social-travel-agency/customers_restaurants.png)
# Reviews

## Example 1

Find number of Reviews per star:

```sql
SELECT
  Stars, count(*) as Count
FROM HasReview
GROUP BY Stars
ORDER BY Count DESC
```

In the _Browse Tab_ of [Studio](../../../studio/README.md), using the query above, this is the obtained list of records:

![](../../../images/demo-dbs/social-travel-agency/query_33_browse.png)

## Example 2

Find all reviewed Services:

```sql
MATCH {class: Services, as: s}-HasReview->{class: Reviews, as: r}
RETURN $pathelements
```

In the _Graph Editor_ included in [Studio](../../../studio/README.md), using the query above, this is the obtained graph:

![](../../../images/demo-dbs/social-travel-agency/query_45_graph.png)

## Example 3

Find all reviewed Services and the Customer who made the review:

```sql
MATCH {class: Services, as: s}-HasReview->{class: Reviews, as: r}<-MadeReview-{class: Customers, as: c}
RETURN $pathelements
```

In the _Graph Editor_ included in [Studio](../../../studio/README.md), using the query above, this is the obtained graph:

![](../../../images/demo-dbs/social-travel-agency/query_46_graph.png)

## Example 4

Find the numbers of reviews per Service:

```sql
SELECT
  @rid as Service_RID,
  Name as Service_Name,
  Type as Service_Type,
  out("HasReview").size() AS ReviewNumbers
FROM `Services`
ORDER BY ReviewNumbers DESC
```

In the _Browse Tab_ of [Studio](../../../studio/README.md), using the query above, this is the obtained list of records:

![](../../../images/demo-dbs/social-travel-agency/query_34_browse.png)

## Example 5

{% include "./include-file-2.md" %}

## Example 6

{% include "./include-file-3.md" %}

# Friendship

## Example 1

Find Santo's Friends:

```sql
MATCH {Class: Profiles, as: profile, where: (Name='Santo' AND Surname='OrientDB')}-HasFriend-{Class: Profiles, as: friend}
RETURN $pathelements
```

In the _Graph Editor_ included in [Studio](../../../studio/README.md), using _'RETURN $pathelements'_ as `RETURN` clause, this is the obtained graph:

![](../../../images/demo-dbs/social-travel-agency/query_1_graph.png)

In the _Browse Tab_ of [Studio](../../../studio/README.md), using _'RETURN friend.@Rid as Friend_RID, friend.Name as Friend_Name, friend.Surname as Friend_Surname'_ as `RETURN` clause, this is the obtained list of records (onl


ut_dev->close = keyspan_close;

	/*
	 * Initialize the URB to access the device.
	 * The urb gets sent to the device in keyspan_open()
	 */
	usb_fill_int_urb(remote->irq_urb,
			 remote->udev,
			 usb_rcvintpipe(remote->udev, endpoint->bEndpointAddress),
			 remote->in_buffer, RECV_SIZE, keyspan_irq_recv, remote,
			 endpoint->bInterval);
	remote->irq_urb->transfer_dma = remote->in_dma;
	remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	/* we can register the device now, as it is ready */
	error = input_register_device(remote->input);
	if (error)
		goto fail3;

	/* save our data pointer in this interface device */
	usb_set_intfdata(interface, remote);

	return 0;

 fail3:	usb_free_urb(remote->irq_urb);
 fail2:	usb_free_coherent(udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
 fail1:	kfree(remote);
	input_free_device(input_dev);

	return error;
}

/*
 * Routine called when a device is disconnected from the USB.
 */
static void keyspan_disconnect(struct usb_interface *interface)
{
	struct usb_keyspan *remote;

	remote = usb_get_intfdata(interface);
	usb_set_intfdata(interface, NULL);

	if (remote) {	/* We have a valid driver structure so clean up everything we allocated. */
		input_unregister_device(remote->input);
		usb_kill_urb(remote->irq_urb);
		usb_free_urb(remote->irq_urb);
		usb_free_coherent(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
		kfree(remote);
	}
}

/*
 * Standard driver set up sections
 */
static struct usb_driver keyspan_driver =
{
	.name =		"keyspan_remote",
	.probe =	keyspan_probe,
	.disconnect =	keyspan_disconnect,
	.id_table =	keyspan_table
};

module_usb_driver(keyspan_driver);

MODULE_DEVICE_TABLE(usb, keyspan_table);
MODULE_AUTHOR("Michael Downey <downey@zymeta.com>");
MODULE_DESCRIPTION("Driver for the USB Keyspan remote control.");
MODULE_LICENSE("GPL");


re = new RegExp(s_v);
      if (re.test(stem))
        w = stem + "i";
    }

    // Step 2
    re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      suffix = fp[2];
      re = new RegExp(mgr0);
      if (re.test(stem))
        w = stem + step2list[suffix];
    }

    // Step 3
    re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      suffix = fp[2];
      re = new RegExp(mgr0);
      if (re.test(stem))
        w = stem + step3list[suffix];
    }

    // Step 4
    re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
    re2 = /^(.+?)(s|t)(ion)$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      re = new RegExp(mgr1);
      if (re.test(stem))
        w = stem;
    }
    else if (re2.test(w)) {
      var fp = re2.exec(w);
      stem = fp[1] + fp[2];
      re2 = new RegExp(mgr1);
      if (re2.test(stem))
        w = stem;
    }

    // Step 5
    re = /^(.+?)e$/;
    if (re.test(w)) {
      var fp = re.exec(w);
      stem = fp[1];
      re = new RegExp(mgr1);
      re2 = new RegExp(meq1);
      re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
        w = stem;
    }
    re = /ll$/;
    re2 = new RegExp(mgr1);
    if (re.test(w) && re2.test(w)) {
      re = /.$/;
      w = w.replace(re,"");
    }

    // and turn initial Y back to y
    if (firstch == "y")
      w = firstch.toLowerCase() + w.substr(1);
    return w;
  }
}

/**
 * Search Module
 */
var Search = {

  _index : null,
  _queued_query : null,
  _pulse_status : -1,

  init : function() {
      var params = $.getQueryParameters();
      if (params.q) {
          var query = params.q[0];
          $('input[name="q"]')[0].value = query;
          this.performSearch(query);
      }
  },

  loadIndex : function(url) {
    $.ajax({type: "GET", url: url, data: null, success: null,
            dataType: "script", cache: true});
  },

  setIndex : function(index) {
    var q;
    this._index = index;
    if ((q = this._queued_query) !== null) {
      this._queued_query = null;
      Search.query(q);
    }
  },

  hasIndex : function() {
      return this._index !== null;
  },

  deferQuery : function(query) {
      this._queued_query = query;
  },

  stopPulse : function() {
      this._pulse_status = 0;
  },

  startPulse : function() {
    if (this._pulse_status >= 0)
        return;
    function pulse() {
      Search._pulse_status = (Search._pulse_status + 1) % 4;
      var dotString = '';
      for (var i = 0; i < Search._pulse_status; i++)
        dotString += '.';
      Search.dots.text(dotString);
      if (Search


           size=(1, 1),  # Minimal size
            anchor="top left",
            **kwargs,
        )

        # Create separate independent windows as attributes
        self.top_left = Window(
            anchor="top left",
            title="modus-widgets-topleft",
            orientation="h",
            layer="bottom",
            visible=False,  # Start hidden until content ready
            child=Box(
                name="desktop-widgets-container",
                children=[
                    DateContainer(),
                    WeatherContainer(),
                    CalendarContainer(),
                ],
            ),
        )

        self.bottom_left = Window(
            anchor="bottom right",
            title="modus-widgets-bottomright",
            orientation="h",
            layer="bottom",
            visible=False,  # Start hidden until content ready
            child=Box(
                name="desktop-widgets-container",
                children=[
                    CpuInfo(),
                    RamInfo(),
                ],
            ),
        )

        # Show widgets after initialization is complete
        self.top_left.set_visible(True)
        self.bottom_left.set_visible(True)


 {
				appendToGroup(menu, ISynchronizePageConfiguration.SYNCHRONIZE_GROUP, configureSchedule);
			}
		}
	}
}
/*[INCLUDE-IF Sidecar18-SE]*/
/*
 * Copyright IBM Corp. and others 2004
 *
 * This program and the accompanying materials are made available under
 * the terms of the Eclipse Public License 2.0 which accompanies this
 * distribution and is available at https://www.eclipse.org/legal/epl-2.0/
 * or the Apache License, Version 2.0 which accompanies this distribution and
 * is available at https://www.apache.org/licenses/LICENSE-2.0.
 *
 * This Source Code may also be made available under the following
 * Secondary Licenses when the conditions for such availability set
 * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU
 * General Public License, version 2 with the GNU Classpath
 * Exception [1] and GNU General Public License, version 2 with the
 * OpenJDK Assembly Exception [2].
 *
 * [1] https://www.gnu.org/software/classpath/license.html
 * [2] https://openjdk.org/legal/assembly-exception.html
 *
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
 */
package com.ibm.dtfj.image.j9;

import java.util.Iterator;

import com.ibm.dtfj.image.CorruptDataException;
import com.ibm.dtfj.image.DataUnavailable;
import com.ibm.dtfj.image.ImagePointer;
import com.ibm.dtfj.image.ImageProcess;
import com.ibm.dtfj.image.ImageModule;

public class ImageStackFrame implements com.ibm.dtfj.image.ImageStackFrame
{
	private ImageAddressSpace _space;
	private String _procedureName = null;
	private ImagePointer _procedureAddress;
	private ImagePointer _basePointer;

	public ImageStackFrame(ImageAddressSpace space, ImagePointer procedureAddress, ImagePointer basePointer) {
		_space = space;
		_procedureAddress = procedureAddress;
		_basePointer = basePointer;
	}

	public ImagePointer getProcedureAddress() throws CorruptDataException
	{
		return _procedureAddress;
	}

	public ImagePointer getBasePointer() throws CorruptDataException
	{
		return _basePointer;
	}

	public String getProcedureName() throws CorruptDataException
	{
		if (null == _procedureName) {
			ImageModule bestModule = null;
			ImageSymbol bestClosest = null;
			long bestDelta = Long.MAX_VALUE;

			for (Iterator i = this._space.getProcesses(); i.hasNext(); ) {
				Object nexti = i.next();
				if (nexti instanceof CorruptData) continue;
				ImageProcess process = (ImageProcess)nexti;
				if ((_procedureAddress.getAddress() != ((1L << process.getPointerSize()) - 1))) {
					try {
						ImageModule module = process.getExecutable();
						ImageSymbol closest = getClosestSymbolFrom(module);
						long delta = getDelta(module, closest);
						if (delta >= 0 && delta < bestDelta) {
							bestModule = module;
							bestClosest = closest;
							bestDelta = delta;
						}
					} catch (DataUnavailable e) {
					} catch (CorruptDataException e) {
					}
					try {
						for (Iterator j = process.getLibraries(); j.hasNext(); ) {
							Object next = j.next();
							if (next instanceof CorruptData) continue;
							ImageModule module = (ImageModule)next;
							ImageSymbol closest = getClosestSymbolFrom(module);
							long delta = getDelta(module, closest);
							if (delta >= 0 && delta < bestDelta) {
								bestModule = module;
								bestClosest = closest;
								bestDelta = delta;
							}
						}
					} catch (DataUnavailable e) {
					} c


<< "[          ] next_marker is: = " << next_marker << std::endl;

  marker = next_marker;
  cls_rgw_gc_queue_list_entries(ioctx, queue_name, marker, max, expired_only, list_info3, &truncated, next_marker);
  it = list_info3.front();
  ASSERT_EQ(1, list_info3.size());
  ASSERT_EQ(false, truncated);
  ASSERT_EQ("chain-1", it.tag);
}

#if 0 // TODO: fix or remove defer_gc()
TEST(cls_rgw_gc, gc_queue_ops3)
{
  //Testing remove queue entries
  string queue_name = "my-third-queue";
  uint64_t queue_size = 501, num_urgent_data_entries = 10;
  librados::ObjectWriteOperation op;
  op.create(true);
  cls_rgw_gc_queue_init(op, queue_size, num_urgent_data_entries);
  ASSERT_EQ(0, ioctx.operate(queue_name, &op));

  uint64_t size = 0;
  int ret = cls_rgw_gc_queue_get_capacity(ioctx, queue_name, size);
  ASSERT_EQ(0, ret);
  ASSERT_EQ(size, queue_size);

  //Test remove queue, when queue is empty
  librados::ObjectWriteOperation remove_op;
  string marker1;
  uint64_t num_entries = 2;
  cls_rgw_gc_queue_remove_entries(remove_op, num_entries);
  ASSERT_EQ(0, ioctx.operate(queue_name, &remove_op));

  cls_rgw_gc_obj_info defer_info;

  //Test enqueue
  for (int i = 0; i < 2; i++) {
    string tag = "chain-" + to_string(i);
    librados::ObjectWriteOperation op;
    cls_rgw_gc_obj_info info;

    cls_rgw_obj obj1, obj2;
    create_obj(obj1, i, 1);
    create_obj(obj2, i, 2);
    info.chain.objs.push_back(obj1);
    info.chain.objs.push_back(obj2);

    info.tag = tag;
    cls_rgw_gc_queue_enqueue(op, 5, info);
    ASSERT_EQ(0, ioctx.operate(queue_name, &op));
    if (i == 0)
      defer_info = info;
  }

  //Test defer entry for 1st element
  librados::ObjectWriteOperation defer_op;
  cls_rgw_gc_queue_defer_entry(defer_op, 10, defer_info);
  ASSERT_EQ(0, ioctx.operate(queue_name, &defer_op));

  //Test list queue
  list<cls_rgw_gc_obj_info> list_info1, list_info2;
  string marker, next_marker;
  uint64_t max = 2;
  bool expired_only = false, truncated;
  cls_rgw_gc_queue_list_entries(ioctx, queue_name, marker, max, expired_only, list_info1, &truncated, next_marker);
  ASSERT_EQ(2, list_info1.size());

  int i = 0;
  for (auto it : list_info1) {
    std::cerr << "[          ] list info tag = " << it.tag << std::endl;
    if (i == 0) {
      ASSERT_EQ("chain-1", it.tag);
    }
    if (i == 1) {
      ASSERT_EQ("chain-0", it.tag);
    }
    i++;
  }

  //Test remove entries
  num_entries = 2;
  cls_rgw_gc_queue_remove_entries(remove_op, num_entries);
  ASSERT_EQ(0, ioctx.operate(queue_name, &remove_op));


合
     */
    List<Dept> selectDeptList(Dept dept);

    /**
     * 查询部门管理树
     *
     * @param dept 部门信息
     * @return 所有部门信息
     */
    List<Map<String, Object>> selectDeptTree(Dept dept);

    /**
     * 根据角色ID查询菜单
     *
     * @param role 角色对象
     * @return 菜单列表
     */
    List<Map<String, Object>> roleDeptTreeData(Role role);

    /**
     * 查询部门人数
     *
     * @param parentId 父部门ID
     * @return 结果
     */
    int selectDeptCount(Long parentId);

    /**
     * 查询部门是否存在用户
     *
     * @param deptId 部门ID
     * @return 结果 true 存在 false 不存在
     */
    boolean checkDeptExistUser(Long deptId);

    /**
     * 删除部门管理信息
     *
     * @param deptId 部门ID
     * @return 结果
     */
    int deleteDeptById(Long deptId);

    /**
     * 新增保存部门信息
     *
     * @param dept 部门信息
     * @return 结果
     */
    int insertDept(Dept dept);

    /**
     * 修改保存部门信息
     *
     * @param dept 部门信息
     * @return 结果
     */
    int updateDept(Dept dept);

    /**
     * 根据部门ID查询信息
     *
     * @param deptId 部门ID
     * @return 部门信息
     */
    Dept selectDeptById(Long deptId);

    /**
     * 校验部门名称是否唯一
     *
     * @param dept 部门信息
     * @return 结果
     */
    String checkDeptNameUnique(Dept dept);

}
package com.luckyframe.common.netty;

import java.io.File;
import java.io.Serializable;

public class FileUploadFile implements Serializable {

    private static final long serialVersionUID = 1L;
    private File file;// 文件
    private String file_md5;// 文件名
    private int starPos;// 开始位置
    private byte[] bytes;// 文件字节数组
    private int endPos;// 结尾位置

    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        this.file = file;
    }

    public String getFile_md5() {
        return file_md5;
    }

    public void setFile_md5(String file_md5) {
        this.file_md5 = file_md5;
    }

    public int getStarPos() {
        return starPos;
    }

    public void setStarPos(int starPos) {
        this.starPos = starPos;
    }

    public byte[] getBytes() {
        return bytes;
    }

    public void setBytes(byte[] bytes) {
        this.bytes = bytes;
    }

    public int getEndPos() {
        return endPos;
    }

    public void setEndPos(int endPos) {
        this.endPos = endPos;
    }

    public static long getSerialversionuid() {
        return serialVersionUID;
    }
}package com.luckyframe.common.netty;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.luckyframe.framework.config.LuckyFrameConfig;
import com.luckyframe.project.monitor.job.domain.Job;
import com.luckyframe.project.monitor.job.service.IJobService;
import com.luckyframe.project.system.client.domain.Client;
import com.luckyframe.project.system.client.service.IClientService;
import io.netty.buffer.Unpoo


ttribute("clip-path", "");
        //     delete attrss.clip;
        // }
    },

    /**
     * Insert or move a given sprite's element to the correct place in the DOM list for its zIndex
     * @param {Ext.draw.Sprite} sprite
     */
    applyZIndex: function(sprite) {
        var me = this,
            items = me.items,
            idx = items.indexOf(sprite),
            el = sprite.el,
            prevEl;
        if (me.el.dom.childNodes[idx + 2] !== el.dom) { //shift by 2 to account for defs and bg rect
            if (idx > 0) {
                // Find the first previous sprite which has its DOM element created already
                do {
                    prevEl = items.getAt(--idx).el;
                } while (!prevEl && idx > 0);
            }
            el.insertAfter(prevEl || me.bgRect);
        }
        sprite.zIndexDirty = false;
    },

    createItem: function (config) {
        var sprite = new Ext.draw.Sprite(config);
        sprite.surface = this;
        return sprite;
    },

    addGradient: function(gradient) {
        gradient = Ext.draw.Draw.parseGradient(gradient);
        var me = this,
            ln = gradient.stops.length,
            vector = gradient.vector,
            //Safari does not handle linear gradients correctly in quirksmode
            //ref: https://bugs.webkit.org/show_bug.cgi?id=41952
            //ref: EXTJSIV-1472
            usePlain = Ext.isSafari && !Ext.isStrict,
            gradientEl, stop, stopEl, i, gradientsMap;

        gradientsMap = me.gradientsMap || {};

        if (!usePlain) {
            if (gradient.type == "linear") {
                gradientEl = me.createSvgElement("linearGradient");
                gradientEl.setAttribute("x1", vector[0]);
                gradientEl.setAttribute("y1", vector[1]);
                gradientEl.setAttribute("x2", vector[2]);
                gradientEl.setAttribute("y2", vector[3]);
            }
            else {
                gradientEl = me.createSvgElement("radialGradient");
                gradientEl.setAttribute("cx", gradient.centerX);
                gradientEl.setAttribute("cy", gradient.centerY);
                gradientEl.setAttribute("r", gradient.radius);
                if (Ext.isNumber(gradient.focalX) && Ext.isNumber(gradient.focalY)) {
                    gradientEl.setAttribute("fx", gradient.focalX);
                    gradientEl.setAttribute("fy", gradient.focalY);
                }
            }
            gradientEl.id = gradient.id;
            me.getDefs().appendChild(gradientEl);
            for (i = 0; i < ln; i++) {
                stop = gradient.stops[i];
                stopEl = me.createSvgElement("stop");
                stopEl.setAttribute("offset", stop.offset + "%");
                stopEl.setAttribute("stop-color", stop.color);
                stopEl.setAttribute("stop-opacity",stop.opacity);
                gradientEl.appendChild(stopEl);
            }
        } else {
            gradientsMap['url(#' + gradient.id + ')'] = gradient.stops[0].color;
        }
        me.gradientsMap = gradientsMap;
    },

    /**
     * Checks if the specified CSS class exists on this element's DOM node.
     * @param {Ext.draw.Sprite} sprite The sprite to look into.
     * @param {String} className The CSS class to check for
     * @return {Boolean} True if the class exists, else false
     */
    hasCls: function(sprite, className) {
        return className && (' ' + (sprite.el.dom.getAttribute('class') || '') + ' ').indexOf(' ' + className + ' ') != -1;


) compress4Xp(src []byte) ([]byte, error) {
	if len(src) < 12 {
		return nil, ErrIncompressible
	}
	// Add placeholder for output length
	s.Out = s.Out[:6]

	segmentSize := (len(src) + 3) / 4
	var wg sync.WaitGroup
	wg.Add(4)
	for i := range 4 {
		toDo := src
		if len(toDo) > segmentSize {
			toDo = toDo[:segmentSize]
		}
		src = src[len(toDo):]

		// Separate goroutine for each block.
		go func(i int) {
			s.tmpOut[i] = s.compress1xDo(s.tmpOut[i][:0], toDo)
			wg.Done()
		}(i)
	}
	wg.Wait()
	for i := range 4 {
		o := s.tmpOut[i]
		if len(o) > math.MaxUint16 {
			// We cannot store the size in the jump table
			return nil, ErrIncompressible
		}
		// Write compressed length as little endian before block.
		if i < 3 {
			// Last length is not written.
			s.Out[i*2] = byte(len(o))
			s.Out[i*2+1] = byte(len(o) >> 8)
		}

		// Write output.
		s.Out = append(s.Out, o...)
	}
	return s.Out, nil
}

// countSimple will create a simple histogram in s.count.
// Returns the biggest count.
// Does not update s.clearCount.
func (s *Scratch) countSimple(in []byte) (max int, reuse bool) {
	reuse = true
	_ = s.count // Assert that s != nil to speed up the following loop.
	for _, v := range in {
		s.count[v]++
	}
	m := uint32(0)
	if len(s.prevTable) > 0 {
		for i, v := range s.count[:] {
			if v == 0 {
				continue
			}
			if v > m {
				m = v
			}
			s.symbolLen = uint16(i) + 1
			if i >= len(s.prevTable) {
				reuse = false
			} else if s.prevTable[i].nBits == 0 {
				reuse = false
			}
		}
		return int(m), reuse
	}
	for i, v := range s.count[:] {
		if v == 0 {
			continue
		}
		if v > m {
			m = v
		}
		s.symbolLen = uint16(i) + 1
	}
	return int(m), false
}

func (s *Scratch) canUseTable(c cTable) bool {
	if len(c) < int(s.symbolLen) {
		return false
	}
	for i, v := range s.count[:s.symbolLen] {
		if v != 0 && c[i].nBits == 0 {
			return false
		}
	}
	return true
}

//lint:ignore U1000 used for debugging
func (s *Scratch) validateTable(c cTable) bool {
	if len(c) < int(s.symbolLen) {
		return false
	}
	for i, v := range s.count[:s.symbolLen] {
		if v != 0 {
			if c[i].nBits == 0 {
				return false
			}
			if c[i].nBits > s.actualTableLog {
				return false
			}
		}
	}
	return true
}

// minTableLog provides the minimum logSize to safely represent a distribution.
func (s *Scratch) minTableLog() uint8 {
	minBitsSrc := highBit32(uint32(s.srcLen)) + 1
	minBitsSymbols := highBit32(uint32(s.symbolLen-1)) + 2
	if minBitsSrc < minBitsSymbo


ms-fill-lower {
    background-color: #f0f0f0;
    border-radius: 99rem;
    border: 1px solid #71767a;
}
.usa-range::-ms-fill-upper {
    background-color: #f0f0f0;
    border-radius: 99rem;
    border: 1px solid #71767a;
}

.usa-textarea {
    height: 10rem;
}

.usa-time-picker {
    width: 10em;
}

/*
----------------------------------------
Set basic font rules for the font
utilities to reference.
----------------------------------------
*/
[class*="font-mono-"] {
    font-family:
        Roboto Mono Web,
        Bitstream Vera Sans Mono,
        Consolas,
        Courier,
        monospace;
}

[class*="font-sans-"] {
    font-family:
        Public Sans Web,
        -apple-system,
        BlinkMacSystemFont,
        Segoe UI,
        Roboto,
        Helvetica,
        Arial,
        sans-serif,
        Apple Color Emoji,
        Segoe UI Emoji,
        Segoe UI Symbol;
}

[class*="font-ui-"] {
    font-family:
        Public Sans Web,
        -apple-system,
        BlinkMacSystemFont,
        Segoe UI,
        Roboto,
        Helvetica,
        Arial,
        sans-serif,
        Apple Color Emoji,
        Segoe UI Emoji,
        Segoe UI Symbol;
}

[class*="font-heading-"] {
    font-family:
        Public Sans Web,
        -apple-system,
        BlinkMacSystemFont,
        Segoe UI,
        Roboto,
        Helvetica,
        Arial,
        sans-serif,
        Apple Color Emoji,
        Segoe UI Emoji,
        Segoe UI Symbol;
}

[class*="font-body-"] {
    font-family:
        Public Sans Web,
        -apple-system,
        BlinkMacSystemFont,
        Segoe UI,
        Roboto,
        Helvetica,
        Arial,
        sans-serif,
        Apple Color Emoji,
        Segoe UI Emoji,
        Segoe UI Symbol;
}

[class*="font-code-"] {
    font-family:
        Roboto Mono Web,
        Bitstream Vera Sans Mono,
        Consolas,
        Courier,
        monospace;
}

[class*="font-alt-"] {
    font-family:
        Roboto Mono Web,
        Bitstream Vera Sans Mono,
        Consolas,
        Courier,
        monospace;
}

/*
========================================
ASPECT
----------------------------------------
usage:
  .aspect-[value]
----------------------------------------
output:
  padding-left: 0;
  padding-right: 0;
  padding-top: 0;
  padding-bottom: 100%;
----------------------------------------
example:
  .aspect-16x9
----------------------------------------
*/
.add-aspect-9x16 {
    box-sizing: border-box;
    height: 0;
    overflow: hidden;
    padding-bottom: 177.77778%;
    position: relative;
}
@supports (aspect-ratio: 1) {
    .add-aspect-9x16 {
        height: inherit;
        padding: inherit;
        aspect-ratio: 0.5625;
        max-width: 100%;
    }
    .add-aspect-9x16 > * {
        position: absolute;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
    }
    img.add-aspect-9x16,
    .add-aspect-9x16 > img {
        object-fit: cover;
    }
}

.add-aspect-16x9 {
    box-sizing: border-box;
    height: 0;
    overflow: hidden;
    padding-bottom: 56.25%;
    position: relative;
}
@supports (aspect-ratio: 1) {
    .add-aspect-16x9 {
        height: inherit;
        padding: inherit;
        aspect-ratio: 1.7777777778;
        max-width: 100


   seg_logits, seg_label, ignore_index=self.ignore_index)
        return loss

    def predict_by_feat(self, seg_logits: Tensor,
                        batch_img_metas: List[dict]) -> Tensor:
        """Transform a batch of output seg_logits to the input shape.

        Args:
            seg_logits (Tensor): The output from decode head forward function.
            batch_img_metas (list[dict]): Meta information of each image, e.g.,
                image size, scaling factor, etc.

        Returns:
            Tensor: Outputs segmentation logits map.
        """

        seg_logits = resize(
            input=seg_logits,
            size=batch_img_metas[0]['img_shape'],
            mode='bilinear',
            align_corners=self.align_corners)
        return seg_logits


[[COND:.+]] = load <4 x i32>
  // CHECK: %[[LHS:.+]] = load <4 x float>
  // CHECK: %[[RHS:.+]] = load float
  // CHECK: %[[RHS_SPLAT_INSERT:.+]] = insertelement <4 x float> poison, float %[[RHS]], i32 0
  // CHECK: %[[RHS_SPLAT:.+]] = shufflevector <4 x float> %[[RHS_SPLAT_INSERT]], <4 x float> poison, <4 x i32> zeroinitializer
  // CHECK: %[[NEZERO:.+]] = icmp ne <4 x i32> %[[COND]], zeroinitializer
  // CHECK: %[[SELECT:.+]] = select <4 x i1> %[[NEZERO]], <4 x float> %[[LHS]], <4 x float> %[[RHS_SPLAT]]

  four_ll ? four_doubles : 6.0;
  // CHECK: %[[COND:.+]] = load <4 x i64>
  // CHECK: %[[LHS:.+]] = load <4 x double>
  // CHECK: %[[NEZERO:.+]] = icmp ne <4 x i64> %[[COND]], zeroinitializer
  // CHECK: %[[SELECT:.+]] = select <4 x i1> %[[NEZERO]], <4 x double> %[[LHS]], <4 x double> <double 6.{{.+}}, double 6.{{.+}}, double 6.{{.+}}>

  four_ll ? four_ll : 6.0;
  // CHECK: %[[COND:.+]] = load <4 x i64>
  // CHECK: %[[LHS:.+]] = load <4 x i64>
  // CHECK: %[[NEZERO:.+]] = icmp ne <4 x i64> %[[COND]], zeroinitializer
  // CHECK: %[[SELECT:.+]] = select <4 x i1> %[[NEZERO]], <4 x i64> %[[LHS]], <4 x i64> <i64 6, i64 6, i64 6, i64 6>

  four_ll ? four_ll : 6;
  // CHECK: %[[COND:.+]] = load <4 x i64>
  // CHECK: %[[LHS:.+]] = load <4 x i64>
  // CHECK: %[[NEZERO:.+]] = icmp ne <4 x i64> %[[COND]], zeroinitializer
  // CHECK: %[[SELECT:.+]] = select <4 x i1> %[[NEZERO]], <4 x i64> %[[LHS]], <4 x i64> <i64 6, i64 6, i64 6, i64 6>

  four_ll ? four_ll : some_int;
  // CHECK: %[[COND:.+]] = load <4 x i64>
  // CHECK: %[[LHS:.+]] = load <4 x i64>
  // CHECK: %[[RHS:.+]] = load i32
  // CHECK: %[[RHS_CONV:.+]] = sext i32 %[[RHS]] to i64
  // CHECK: %[[RHS_SPLAT_INSERT:.+]] = insertelement <4 x i64> poison, i64 %[[RHS_CONV]], i32 0
  // CHECK: %[[RHS_SPLAT:.+]] = shufflevector <4 x i64> %[[RHS_SPLAT_INSERT]], <4 x i64> poison, <4 x i32> zeroinitializer
  // CHECK: %[[NEZERO:.+]] = icmp ne <4 x i64> %[[COND]], zeroinitializer
  // CHECK: %[[SELECT:.+]] = select <4 x i1> %[[NEZERO]], <4 x i64> %[[LHS]], <4 x i64> %[[RHS_SPLAT]]

  four_ll ? four_ll : some_ll;
  // CHECK: %[[COND:.+]] = load <4 x i64>
  // CHECK: %[[LHS:.+]] = load <4 x i64>
  // CHECK: %[[RHS:.+]] = load i64
  // CHECK: %[[RHS_SPLAT_INSERT:.+]] = insertelement <4 x


your bags."], settings.keepBankQuantity, settings.restockQuantity)
				else
					return format(L["Warehousing will move a max of %d of each item in this group keeping %d of each item back when bags > bank/gbank."], settings.keepBankQuantity)
				end
			end
		else
			if settings.restockQtyEnabled then
				return format(L["Warehousing will move a max of %d of each item in this group keeping %d of each item back when bank/gbank > bags. Restock will maintain %d items in your bags."], settings.moveQuantity, settings.keepBankQuantity, settings.restockQuantity)
			else
				return format(L["Warehousing will move a max of %d of each item in this group keeping %d of each item back when bank/gbank > bags."], settings.moveQuantity, settings.keepBankQuantity)
			end
		end
	elseif settings.moveQtyEnabled then
		if settings.restockQtyEnabled then
			return format(L["Warehousing will move a max of %d of each item in this group. Restock will maintain %d items in your bags."], settings.moveQuantity, settings.restockQuantity)
		else
			return format(L["Warehousing will move a max of %d of each item in this group."], settings.moveQuantity)
		end
	else
		if settings.restockQtyEnabled then
			return format(L["Warehousing will move all of the items in this group. Restock will maintain %d items in your bags."], settings.restockQuantity)
		else
			return L["Warehousing will move all of the items in this group."]
		end
	end
end

function TSM:IsOperationIgnored(operationName)
	TSMAPI:UpdateOperation("Warehousing", operationName)
	local operation = TSM.operations[operationName]
	if not operation then return end
	local playerKey = UnitName("player").." - "..TSM.db.keys.factionrealm
	return operatio


"test box":"[电] 试验箱",
"test bus":"[计] 测试总线",
"test cabinet":"[化] 测试室; 化验室",
"test card":"[计] 测试卡",
"test carriage":"[化] 测试车",
"test case":"[计] 检查实例",
"test case description":"[计] 检测实例描述",
"test case generation":"[计] 检测实例生成",
"test chart":"[电] 测量图",
"test check":"[化] 试验检查\\n[经] 抽查",
"test circuit":"[电] 测验用电路",
"test clip":"[电] 测验式",
"test cock":"[机] 试验旋塞, 检水旋塞",
"test copy":"[网络] 测试副本",
"test coupon":"[计] 附连试验板\\n[化] 试样",
"test cupola":"[机] 试验用熔铁炉",
"test data":"[计] 测试数据",
"test deck":"[经] 检验卡片组",
"test device":"[化] 测试装置",
"test diet":"[医] 试验饮食",
"test drive":"n. 试车, 试验驾驶",
"test driver":" 试车驾驶员",
"test equipment":" 测试设备",
"test facilities and instruments":"[化] 检测设备和仪器",
"test facility":"[化] 检测手段",
"test flight":"n. 试飞, 试验飞行",
"test fly":" [体]试飞",
"test for":"对...进行测验",
"test for contamination":"[化] 污染试验",
"test for reinforcing plate":"[化] 补强板试验",
"test generation":"[计] 测试生成",
"test generator":"[计] 测试码生成程序; 测试生成程序",
"test glass":"化验杯\\n[化] 试管",
"test glasses":"[医] 试管",
"test in depth":"[经] 深度测验",
"test indicator":"[计] 测试指示器",
"test instrument":"[化] 试验仪器",
"test instrument vehicle":"[网络] 测试仪器车辆",
"test jack":"[电] 测试用插口",
"test joint":"[电] 测联接",
"test key":"[经] 密押码",
"test lead":"[电] 测试引线",
"test line":"[医] 试线(检股骨颈长短)",
"test load":"[化] 试验负荷",
"test lug":"[机] 附体试片",
"test marketing":"[经] 试销",
"test match":"n. 国际板球锦标赛",
"test meal":"[医] 试验餐",
"test method":"[化] 检测方法",
"test model":"[化] 试验模型",
"test of ability":"[经] 能力测验",
"test of achievement":"[经] 成就测验",
"test of agreement":"[化] 适合性测定; 拟合优度检验",
"test of goodness of


w,w")
          (parallel [(match_operand:SI 2 "immediate_operand" "i,i")])))]
  "TARGET_NEON"
{
  int regno = REGNO (operands[1]) + 2 * INTVAL (operands[2]);

  operands[1] = gen_rtx_REG (DImode, regno);

  if (which_alternative == 0)
    return "vst1.64\t{%P1}, %A0  @ v2di";
  else
    return "vmov\t%Q0, %R0, %P1  @ v2di";
}
  [(set_attr "type" "neon_store1_one_lane_q,neon_to_gp_q")]
)

;; Doubleword and quadword arithmetic.

;; NOTE: some other instructions also support 64-bit integer
;; element size, which we could potentially use for "long long" operations.

(define_insn "*add<mode>3_neon"
  [(set (match_operand:VDQ 0 "s_register_operand" "=w")
        (plus:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
		  (match_operand:VDQ 2 "s_register_operand" "w")))]
  "ARM_HAVE_NEON_<MODE>_ARITH"
  "vadd.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
  [(set (attr "type")
      (if_then_else (match_test "<Is_float_mode>")
                    (const_string "neon_fp_addsub_s<q>")
                    (const_string "neon_add<q>")))]
)

(define_insn "*sub<mode>3_neon"
  [(set (match_operand:VDQ 0 "s_register_operand" "=w")
        (minus:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
                   (match_operand:VDQ 2 "s_register_operand" "w")))]
  "ARM_HAVE_NEON_<MODE>_ARITH"
  "vsub.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
  [(set (attr "type")
      (if_then_else (match_test "<Is_float_mode>")
                    (const_string "neon_fp_addsub_s<q>")
                    (const_string "neon_sub<q>")))]
)

(define_insn "*mul<mode>3_neon"
  [(set (match_operand:VDQW 0 "s_register_operand" "=w")
        (mult:VDQW (match_operand:VDQW 1 "s_register_operand" "w")
                   (match_operand:VDQW 2 "s_register_operand" "w")))]
  "ARM_HAVE_NEON_<MODE>_ARITH"
  "vmul.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
  [(set (attr "type")
      (if_then_else (match_test "<Is_float_mode>")
		    (const_string "neon_fp_mul_s<q>")
                    (const_string "neon_mul_<V_elem_ch><q>")))]
)

/* Perform division using multiply-by-reciprocal.
   Reciprocal is calculated using Newton-Raphson method.
   Enabled with -funsafe-math-optimizations -freciprocal-math
   and disabled for -Os since it increases code size .  */

(define_expand "div<VCVTF:mode>3"
  [(set (match_operand:VCVTF


] = "黑色其拉作战坦克",
  [15667] = "维希度斯水滴",
  [15675] = "拍卖师斯托克顿",
  [15676] = "拍卖师亚尔利",
  [15677] = "拍卖师格拉维斯",
  [15678] = "拍卖师塞尔瓦拉斯",
  [15679] = "拍卖师卡扎雷兹",
  [15680] = "拍卖师本纳尔",
  [15681] = "拍卖师奥利雷",
  [15682] = "拍卖师凯恩",
  [15683] = "拍卖师纳克雷米斯",
  [15684] = "拍卖师特里特",
  [15685] = "南海绑匪",
  [15686] = "拍卖师雷克尔",
  [15692] = "黑铁绑匪",
  [15693] = "天启者乔纳森",
  [15694] = "暴风城狂欢者",
  [15695] = "Vek Twins Trigger",
  [15696] = "战备招募官",
  [15698] = "冬天爷爷的助手",
  [15699] = "安静的机械雪人",
  [15700] = "督军格尔库克",
  [15701] = "大元帅斯诺·落雪",
  [15702] = "高阶军士泰加",
  [15703] = "高阶军士格瑞弗德",
  [15704] = "高阶军士凯金",
  [15705] = "冬天爷爷的小助手",
  [15706] = "冬季驯鹿",
  [15707] = "军士长菲兹伯特",
  [15708] = "军士长玛克卢尔",
  [15709] = "军士长希德·月影",
  [15710] = "雪孩子",
  [15712] = "土堆",
  [15713] = "蓝色其拉作战坦克",
  [15714] = "黄色其拉作战坦克",
  [15715] = "绿色其拉作战坦克",
  [15716] = "红色其拉作战坦克",
  [15717] = "Ouro Trigger",
  [15718] = "奥罗甲虫",
  [15719] = "雷霆崖狂欢者",
  [15720] = "木喉先祖",
  [15721] = "机械格林奇",
  [15722] = "莱欧伦·玛尔迪拉斯",
  [15723] = "藏宝海湾狂欢者",
  [15724] = "醉酒的卫兵",
  [15725] = "利爪触须",
  [15726] = "眼球触须",
  [15727] = "克苏恩",
  [15728] = "巨钩触须",
  [15729] = "冬天爷爷的助手",
  [15730] = "Pat\'s Snowclou


 uses the convention of <temp>/<appname> for the temporary
// folder.  Filesystem uses <temp>/<exename>.  We will be migrating exclusively
// to <temp>/<orgname>/<appname> eventually.  Since these are temp folders,
// it's probably ok to orphan them during the transition.
inline bool GetTemporaryFolder(Pathname& path, bool create,
                               const std::string& append) {
  std::string application_name;
  Filesystem::GetApplicationName(&application_name);
  ASSERT(!application_name.empty());
  return Filesystem::GetTemporaryFolder(path, create, &application_name)
         && FinishPath(path, create, append);
}
inline bool GetAppDataFolder(Pathname& path, bool create,
                             const std::string& append) {
  ASSERT(!create); // TODO: Support create flag on Filesystem::GetAppDataFolder.
  return Filesystem::GetAppDataFolder(&path, true)
         && FinishPath(path, create, append);
}
inline bool CleanupTemporaryFolder() {
  Pathname path;
  if (!GetTemporaryFolder(path, false, ""))
    return false;
  if (Filesystem::IsAbsent(path))
    return true;
  if (!Filesystem::IsTemporaryPath(path)) {
    ASSERT(false);
    return false;
  }
  return Filesystem::DeleteFolderContents(path);
}

///////////////////////////////////////////////////////////////////////////////

}  // namespace rtc

#endif // WEBRTC_BASE_PATHUTILS_H__


     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.hippo.ehviewer

import android.os.Build
import android.os.Debug
import com.hippo.util.ReadableTime
import com.hippo.yorozuya.FileUtils
import com.hippo.yorozuya.OSUtils
import java.io.File
import java.io.FileWriter
import java.io.PrintWriter

private fun joinIfStringArray(any: Any?): String = if (any is Array<*>) any.joinToString() else any.toString()

private fun collectClassStaticInfo(clazz: Class<*>): String = clazz.declaredFields.joinToString("\n") {
    "${it.name}=${joinIfStringArray(it.get(null))}"
}

object Crash {
    private fun collectInfo(fw: FileWriter) {
        fw.write("======== PackageInfo ========\n")
        fw.write("PackageName=${BuildConfig.APPLICATION_ID}\n")
        fw.write("VersionName=${BuildConfig.VERSION_NAME}\n")
        fw.write("VersionCode=${BuildConfig.VERSION_CODE}\n")
        fw.write("CommitSha=${BuildConfig.COMMIT_SHA}\n")
        fw.write("BuildTime=${BuildConfig.BUILD_TIME}\n")
        fw.write("\n")

        // Runtime
        fw.write("======== Runtime ========\n")
        fw.write("TopActivity=${EhApplication.application.topActivity?.javaClass?.name}\n")
        fw.write("\n")

        // Device info
        fw.write("======== DeviceInfo ========\n")
        fw.write("${collectClassStaticInfo(Build::class.java)}\n")
        fw.write("${collectClassStaticInfo(Build.VERSION::class.java)}\n")
        fw.write("MEMORY=")
        fw.write(FileUtils.humanReadableByteCount(OSUtils.getAppAllocatedMemory(), false))
        fw.write("\n")
        fw.write("MEMORY_NATIVE=")
        fw.write(FileUtils.humanReadableByteCount(Debug.getNativeHeapAllocatedSize(), false))
        fw.write("\n")
        fw.write("MEMORY_MAX=")
        fw.write(FileUtils.humanReadableByteCount(OSUtils.getAppMaxMemory(), false))
        fw.write("\n")
        fw.write("MEMORY_TOTAL=")
        fw.write(FileUtils.humanReadableByteCount(OSUtils.getTotalMemory(), false))
        fw.write("\n")
        fw.write("\n")
    }

    private fun getThrowableInfo(t: Throwable, fw: FileWriter) {
        val printWriter = PrintWriter(fw)
        t.printStackTrace(printWriter)
        var cause = t.cause
        while (cause != null) {
            cause.printStackTrace(printWriter)
            cause = cause.cause
        }
    }

    fun saveCrashLog(t: Throwable) {
        val dir = AppConfig.getExternalCrashDir() ?: return
        val nowString = ReadableTime.getFilenamableTime()
        val fileName = "crash-$nowString.log"
        val file = File(dir, fileName)
        runCatching {
            FileWriter(file).use { fw ->
                fw.write("TIME=${nowString}\n")
                fw.write("\n")
                collectInfo(fw)
                fw.write("======== CrashInfo ========\n")
                getThrowableInfo(t, fw)
                fw.write("\n")
                fw.flush()
            }
        }.onFailure {
            it.printStackTrace()
            file.delete()
        }
    }
}
/*
 * Copyright 2016 Hippo Seven
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in complian


port edu.duke.cs.osprey.gui.io.fromPDB
import edu.duke.cs.osprey.gui.io.toPDB
import edu.duke.cs.osprey.gui.io.withService
import edu.duke.cs.osprey.molscope.molecule.Molecule
import edu.duke.cs.osprey.service.services.ClashesRequest
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe

class TestProbe : FunSpec({

	context("1cc8") {

		test("protein") {
			withService {

				val mol = Molecule.fromPDB(OspreyGui.getResourceAsString("1cc8.pdb"))
				val results = OspreyService.clashes(ClashesRequest(mol.toPDB()))

				results.groups.getValue("small overlap").run {
					vectors.getValue("orange").size shouldBe 115
					vectors.getValue("red").size shouldBe 32
					vectors.getValue("yellow").size shouldBe 311
					vectors.getValue("yellowtint").size shouldBe 833
				}

				results.groups.getValue("bad overlap").run {
					vectors.getValue("hotpink").size shouldBe 10
				}

				results.groups.getValue("vdw contact").run {
					dots.getValue("sky").size shouldBe 3506
					dots.getValue("green").size shouldBe 2862
					dots.getValue("blue").size shouldBe 4028
					dots.getValue("sea").size shouldBe 2818
				}

				// no H atoms yet, so no Hbonds or salt bridges
			}
		}
	}
})
package edu.duke.cs.osprey.gui.forcefield.eef1

import edu.duke.cs.osprey.confspace.ParametricMolecule
import edu.duke.cs.osprey.confspace.Strand
import edu.duke.cs.osprey.energy.EnergyCalculator
import edu.duke.cs.osprey.energy.ResidueInteractions
import edu.duke.cs.osprey.gui.OspreyGui
import edu.duke.cs.osprey.gui.forcefield.*
import edu.duke.cs.osprey.gui.io.fromOMOL
import edu.duke.cs.osprey.gui.io.toOspreyMol
import edu.duke.cs.osprey.molscope.molecule.Molecule
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.doubles.plusOrMinus
import io.kotest.matchers.shouldBe
import kotlinx.coroutines.runBlocking
import edu.duke.cs.osprey.energy.forcefield.ForcefieldParams as OldFFParams

class TestEnergy : FunSpec({

	/**
	 * Calculate the molecule energy using the new parameterization system.
	 */
	fun Molecule.calcEnergyParameterized(): Double {
		val mol = this
		return runBlocking {

			// parameterize the molecule
			val eef1Params = EEF1ForcefieldParams().apply {
				// use the full scale for testing
				scale = 1.0
			}
			val atomIndex = AtomIndex(mol.atoms)
			val atomsParams = eef1Params.parameterizeAtoms(mol, atomIndex, null)
			val atomPairsParams = eef1Params.parameterizeAtomPairs(listOf(
				ForcefieldParams.MolInfo(0, mol, atomsParams, atomIndex)
			))

			// calculate the energy
			ForcefieldCalculator.calc(atomPairsParams, listOf(
				ForcefieldCalculator.MolInfo(0, mol, mol.atoms, atomIndex, atomsParams)
			))
		}
	}

	fun readM