; Generated with ikazuchi 1.0 by riidefi
; Object File: Balloonfish
; Segments:
;     .text:       0x800cd00c -> 0x800cdd78
;     .data:       0x80578e60 -> 0x8057913c (80578ff0 -> 8057913c (size 0332/0x014c) is greedily claimed anonymous data)
;     .sbss:       0x806b3b30 -> 0x806b3b40
;     .sdata2:     0x806b9e18 -> 0x806b9e50 (806b9e4c -> 806b9e50 (size 0004/0x0004) is greedily claimed anonymous data)

; Symbols Defined
; 800cd00c -> 800cd070 __ct__11BalloonfishFPCc
; 800cd070 -> 800cd264 init__11BalloonfishFRC12JMapInfoIter
; 800cd264 -> 800cd2b8 appear__11BalloonfishFv
; 800cd2b8 -> 800cd30c kill__11BalloonfishFv
; 800cd30c -> 800cd314 control__11BalloonfishFv
; 800cd314 -> 800cd4d8 exeWait__11BalloonfishFv
; 800cd4d8 -> 800cd784 exeDash__11BalloonfishFv
; 800cd784 -> 800cd818 exeStarPointerBind__11BalloonfishFv
; 800cd818 -> 800cd8cc attackSensor__11BalloonfishFP9HitSensorP9HitSensor
; 800cd8cc -> 800cd964 receiveMsgPlayerAttack__11BalloonfishFUlP9HitSensorP9HitSensor
; 800cd964 -> 800cdb9c calcAndSetBaseMtx__11BalloonfishFv
; 800cdb9c -> 800cdbd8 __sinit_\Balloonfish_cpp
; 800cdbd8 -> 800cdbe8 __ct__Q214NrvBalloonfish15HostTypeNrvWaitFv
; 800cdbe8 -> 800cdbf8 __ct__Q214NrvBalloonfish15HostTypeNrvDashFv
; 800cdbf8 -> 800cdc08 __ct__Q214NrvBalloonfish18HostTypeNrvDashEndFv
; 800cdc08 -> 800cdc18 __ct__Q214NrvBalloonfish26HostTypeNrvStarPointerBindFv
; 800cdc18 -> 800cdc64 executeOnEnd__Q214NrvBalloonfish26HostTypeNrvStarPointerBindCFP5Spine
; 800cdc64 -> 800cdc6c execute__Q214NrvBalloonfish26HostTypeNrvStarPointerBindCFP5Spine
; 800cdc6c -> 800cdc74 execute__Q214NrvBalloonfish18HostTypeNrvDashEndCFP5Spine
; 800cdc74 -> 800cdc7c execute__Q214NrvBalloonfish15HostTypeNrvDashCFP5Spine
; 800cdc7c -> 800cdc84 execute__Q214NrvBalloonfish15HostTypeNrvWaitCFP5Spine
; 800cdc84 -> 800cdcb4 __cl__Q22MR49FunctorV0M<P11Balloonfish,M11BalloonfishFPCvPv_v>CFv
; 800cdcb4 -> 800cdd1c clone__Q22MR49FunctorV0M<P11Balloonfish,M11BalloonfishFPCvPv_v>CFP7JKRHeap
; 800cdd1c -> 800cdd78 __dt__11BalloonfishFv
; 80578e60 -> 80578e6c @60749
; 80578f18 -> 80578f28 __vt__Q22MR49FunctorV0M<P11Balloonfish,M11BalloonfishFPCvPv_v>
; 80578f28 -> 80578fa0 __vt__11Balloonfish
; 80578fb0 -> 80578fc0 __vt__Q214NrvBalloonfish26HostTypeNrvStarPointerBind
; 80578fc0 -> 80578fd0


by iNCuBuS++

(15 August 1997, slightly edited by Fravia)

Courtesy of Fravia's page

of reverse engineering

Well,	here is the email snippet

 that precedes this essay:

>> Well, if you had the time... MSVCRT.dll reverse engineering would

>> surely be interesting...

> I did have the time.... Here's my short essay on how to crack WinHacker95

> 2.0. It is intended for Project 7 ("Most Stupid Protection")

I don't need to explain you what MSVCRT.DLL (Micro$oft Visual C++ Run Time library)

is, do I?

(A lesson for lazy and hurried shareware programmers :-)

Cracking WinHacker95 2.0 by iNCuBuS++

      This target is one of those little programs that let you play with

the system settings buried deep within the system registry... settings

that are not otherwise available to the average user.

It's much like TweakUI, though it has a few options more. Since

modifying "hidden" settings in the registry is a serious thing, I expected

that this piece of shareware would have had a serious protection.

Well... I was dead wrong!

      When a programmer writes his program in C++ we can be sure that he's

either in a hurry to finish his work or he's lazy to put a little more effort

in programming in C (not to mention assembler) and debugging his code (he could

be both: in a hurry and lazy, since the two things go most together :-)

Programming in C or asm would give him the power to control every aspect of

his program's functioning (including the protection scheme). But nooo! He just

wants easy money - putting together pieces of code someone else has written,

coercing them into something that he would call HIS work, in a matter of

hours.

      Working in this way he will have absolutely no idea about what is

really inside his program - he just creates and manipulates objects of some "class"

from class libraries (like Micro$oft's MFC)filled with bugs and errors and written

by somebody else.

      How COULD such a lazyhurried guy ever write a good protection scheme?

Well, this program is written in C++ and has the most stupid protection

scheme I have ever seen!

      I was able to extract the serial number from memory in less than 15 minutes

and it would


unMarshalRocev2PerPortSettings
	cnpHolder            Rocev2CNP
	connectionTypeHolder Rocev2QPConnectionType
	dcqcnSettingsHolder  Rocev2DCQCN
}

func NewRocev2PerPortSettings() Rocev2PerPortSettings {
	obj := rocev2PerPortSettings{obj: &otg.Rocev2PerPortSettings{}}
	obj.setDefault()
	return &obj
}

func (obj *rocev2PerPortSettings) msg() *otg.Rocev2PerPortSettings {
	return obj.obj
}

func (obj *rocev2PerPortSettings) setMsg(msg *otg.Rocev2PerPortSettings) Rocev2PerPortSettings {
	obj.setNil()
	proto.Merge(obj.obj, msg)
	return obj
}

type marshalrocev2PerPortSettings struct {
	obj *rocev2PerPortSettings
}

type marshalRocev2PerPortSettings interface {
	// ToProto marshals Rocev2PerPortSettings to protobuf object *otg.Rocev2PerPortSettings
	ToProto() (*otg.Rocev2PerPortSettings, error)
	// ToPbText marshals Rocev2PerPortSettings to protobuf text
	ToPbText() (string, error)
	// ToYaml marshals Rocev2PerPortSettings to YAML text
	ToYaml() (string, error)
	// ToJson marshals Rocev2PerPortSettings to JSON text
	ToJson() (string, error)
}

type unMarshalrocev2PerPortSettings struct {
	obj *rocev2PerPortSettings
}

type unMarshalRocev2PerPortSettings interface {
	// FromProto unmarshals Rocev2PerPortSettings from protobuf object *otg.Rocev2PerPortSettings
	FromProto(msg *otg.Rocev2PerPortSettings) (Rocev2PerPortSettings, error)
	// FromPbText unmarshals Rocev2PerPortSettings from protobuf text
	FromPbText(value string) error
	// FromYaml unmarshals Rocev2PerPortSettings from YAML text
	FromYaml(value string) error
	// FromJson unmarshals Rocev2PerPortSettings from JSON text
	FromJson(value string) error
}

func (obj *rocev2PerPortSettings) Marshal() marshalRocev2PerPortSettings {
	if obj.marshaller == nil {
		obj.marshaller = &marshalrocev2PerPortSettings{obj: obj}
	}
	return obj.marshaller
}

func (obj *rocev2PerPortSettings) Unmarshal() unMarshalRocev2PerPortSettings {
	if obj.unMarshaller == nil {
		obj.unMarshaller = &unMarshalrocev2PerPortSettings{obj: obj}
	}
	return obj.unMarshaller
}

func (m *marshalrocev2PerPortSettings) ToProto() (*otg.Rocev2PerPortSettings, error) {
	err := m.obj.validateToAndFrom()
	if err != nil {
		return nil, err
	}
	return m.obj.msg(), nil
}

func (m *unMarshalrocev2PerPortSettings) FromProto(msg *otg.Rocev2PerPortSettings) (Rocev2PerPortSettings, error) {
	newObj := m.obj.setMsg(msg)
	err := newObj.validateToAndFrom()
	if err != nil {
		return nil, err
	}
	return newObj, nil
}

func (m *marshalrocev2PerPortSettings) ToPbText() (string, error) {
	vErr := m.obj.validateToAndFrom()
	if vErr != nil {
		return "", vErr
	}
	protoMarshal, err := proto.Marshal(m.obj.msg())
	if err != nil {
		return "", err
	}
	return s


 (let x = 0; x < pixelsInput[y].length; x++) {
            // @ts-ignore
            pixelsOutput[y].push(pixelToBinary(pixelsInput[y][x]))
        }
    }
    return pixelsOutput
}

let rValue = 255;

const getObject = (input: Pixel[][], pixel: Pixel, accamulator: Pixel[], color: Color) => {
    const { x, y } = pixel;
    if (input[y][x].marked || input[y][x].type === 'black')
        return accamulator;
    accamulator.push(pixel)
    input[y][x].marked = true;
    input[y][x].color.r = color.r;
    input[y][x].color.g = color.g
    input[y][x].color.b = color.b;
    const u = getObject(input, input[y][x - 1], accamulator, color)
    const d = getObject(input, input[y][x + 1], accamulator, color)
    const l = getObject(input, input[y - 1][x], accamulator, color)
    const r = getObject(input, input[y + 1][x], accamulator, color)
}

const getObjectsOnImage = (input: Pixel[][]) => {
    const objects: Object[] = [];
    let currentPixel: Pixel;
    for (let y = 5; y < input.length - 5; y++) {
        for (let x = 5; x < input[y].length - 5; x++) {
            let currentObject: Pixel[] = [];
            getObject(input, input[y][x], currentObject, {
                r: (x * y) % 255,
                g: (x + y) % 255,
                b: y % 255,
            })
            const tmpObject: Object = {
                pixels: currentObject
            }
            if (currentObject.length > 0)
                objects.push(tmpObject)
            currentObject = []
        }
    }
    return objects.map(object => ({
        ...object,
        countour: getCountour(object.pixels),
        angles: getAngles(object.pixels, input)
    }));
}

const getBoundary = (object: Pixel[]) => {
    const { MAX_SAFE_INTEGER } = Number;
    let u = MAX_SAFE_INTEGER;
    let d = 0;
    let l = MAX_SAFE_INTEGER;
    let r = 0;
    object.forEach(pixel => {
        if (pixel.x > r)
            r = pixel.x
        if (pixel.x < l)
            l = pixel.x
        if (pixel.y < u)
            u = pixel.y
        if (pixel.y > d)
            d = pixel.y
    })
    return { u, d, l, r }
}

const getCountour = (object: Pixel[]) => {
    const boundary = getBoundary(object)
    return boundary;
}

const drawNeighpour = (neighbours: Pixel[], input: Pixel[][]) => {
    neighbours.forEach(neighbour => {
        input[neighbour.y][neighbour.x].color = {
            r: 255,
            g: 0,
            b: 0,
        }
    })
}

const getAngles = (object: Pixel[], input: Pixel[][]) => {
    let countAngles = 0;
    object.forEach(pixel => {
        const neighbours = [
            input[pixel.y - 1][pixel.x + 1],
            input[pixel.y - 1][pixel.x - 1],
            input[pixel.y - 1][pixel.x],
            input[pixel.y + 1][pixel.x + 1],
            input[pixel.y + 1][pixel.x - 1],
            input[pixel.y + 1][pixel.x],
            input[pixel.y][pixel.x + 1],
            input[pixel.y][pixel.x - 1],
        ].filter(neighbour => neighbour.color.r === 0)
        if (neighbours.length > 4) {
            drawNeighpour(neighbou


cbz	x1, .L127
	add	x26, x21, 40960
	add	x25, x26, 600
	mov	x0, x25
	bl	BsInit
	mov	x0, x25
	bl	BsResidBits
	mov	w28, w0
	mov	w1, 32
	mov	x0, x25
	bl	BsGet
	rev	w27, w0
	add	w2, w27, 15
	mov	w1, 32
	lsr	w2, w2, 4
	mov	x0, x25
	str	w2, [x29, 224]
	str	w27, [x29, 232]
	bl	BsGet
	rev	w3, w0
	sub	w0, w27, #32
	cmp	w0, 1888
	add	w0, w3, 15
	lsr	w0, w0, 4
	sub	w1, w3, #32
	str	w0, [x29, 228]
	mov	w0, 1056
	str	w3, [x29, 236]
	ccmp	w1, w0, 2, ls
	bhi	.L133
	add	x27, x20, 40960
	ldr	w0, [x26, 384]
	str	w0, [x29, 184]
	add	x1, x29, 176
	mov	x0, x25
	ldr	w2, [x27, 280]
	bl	Divx3_GetPictureHeader
	cmp	w0, 1
	mov	w22, w0
	bne	.L222
	ldr	w1, [x27, 308]
	cbz	w1, .L223
.L136:
	ldp	w0, w1, [x29, 224]
	ldrb	w2, [x20, 2]
	mul	w3, w0, w1
	str	w3, [x29, 240]
	cbz	w2, .L137
	ldr	w3, [x26, 424]
	cmp	w0, w3
	beq	.L224
.L137:
	ldr	x27, .LC58
	ldr	x4, [x27]
	cbz	x4, .L139
	ldr	w2, [x26, 424]
	mov	w3, 8
	strh	w0, [x29, 124]
	strh	w1, [x29, 126]
	ldr	w0, [x26, 1248]
	ldr	w1, [x26, 428]
	strh	w2, [x29, 120]
	add	x2, x29, 120
	strh	w1, [x29, 122]
	mov	w1, 2
	blr	x4
.L139:
	ldr	w0, [x26, 1248]
	bl	FSP_GetFspType
	cbnz	w0, .L140
	add	x3, x29, 272
	ldr	w0, [x26, 1248]
	add	x2, x29, 116
	add	x1, x29, 112
	stp	wzr, wzr, [x29, 112]
	str	wzr, [x3, -152]!
	bl	VCTRL_GetChanImgNum
	ldr	x0, [x21]
	ldr	w2, [x0, 748]
	cmp	w2, 1
	beq	.L225
.L140:
	add	x3, x20, 40960
	add	x1, x26, 640
	mov	x27, x3
	ldr	w0, [x26, 1248]
	str	x1, [x29, 104]
	mov	w2, 1
	ldr	w1, [x3, 392]
	bl	FSP_ClearLogicFs
	str	wzr, [x27, 392]
	ldr	w0, [x26, 1248


            }
        }
    }

    // 修改健康头条移除方法
    @SuppressLint("DiscouragedApi")
    private fun removeHealthHeadlinesCover(viewGroup: ViewGroup) {
        val headlinesCoverId = viewGroup.resources.getIdentifier("health_headlines_cover", "id", viewGroup.context.packageName)

        fun findViewWithId(parent: ViewGroup): View? {
            for (i in 0 until parent.childCount) {
                val child = parent.getChildAt(i)
                if (child.id == headlinesCoverId) {
                    return child
                }
                if (child is ViewGroup) {
                    val result = findViewWithId(child)
                    if (result != null) {
                        return result
                    }
                }
            }
            return null
        }

        val targetView = findViewWithId(viewGroup)
        if (targetView != null) {
            try {
                // 尝试直接移除父布局
                val parent = targetView.parent as? ViewGroup
                if (parent != null) {
                    val grandParent = parent.parent as? ViewGroup
                    if (grandParent != null) {
                        grandParent.removeView(parent)
                        XposedBridge.log("Removed health headlines cover's parent layout (first attempt)")
                        return
                    }
                }

                // 如果上面失败，尝试直接移除目标视图
                val directParent = targetView.parent as? ViewGroup
                if (directParent != null) {
                    directParent.removeView(targetView)
                    XposedBridge.log("Removed health headlines cover directly")
                }
            } catch (e: Exception) {
                XposedBridge.log("Error removing health headlines cover: ${e.message}")
            }
        }
    }

    // 移除所有的营销区域
    @SuppressLint("DiscouragedApi")
    private fun removeAllMarketingAreas(viewGroup: ViewGroup) {
        val marketingAreaId = viewGroup.resources.getIdentifier("marketing_area", "id", viewGroup.context.packageName)

        fun findAndRemoveMarketingAreas(parent: ViewGroup) {
            // 从后向前遍历，这样删除时不会影响索引
            for (i in (parent.childCount - 1) downTo 0) {
                val child = parent.getChildAt(i)

                // 如果找到marketing_area，移除它
                if (child.id == marketingAreaId) {
                    parent.removeView(child)
                    XposedBridge.log("Removed a marketing_area")
                }

                // 递归检查子ViewGroup
                if (child is ViewGroup) {
                    findAndRemoveMarketingAreas(child)
                }
            }
        }

        try {
            findAndRemoveMarketingAreas(viewGroup)
        } catch (e: Exception) {
            XposedBridge.log("Error removing marketing areas: ${e.message}")
        }
    }

    // 移除所有的gone_layout
    @SuppressLint("DiscouragedApi")
    private fun removeAllGoneLayouts(viewGroup: ViewGroup) {
        val goneLayoutId = viewGroup.resources.getIdentifier("gone_layout", "id", viewGroup.context.packageName)

        fun findAndRemoveGoneLayouts(parent: ViewGroup) {
            // 从后向前遍历，这样删除时不会影响索引
            for (i in (parent.childCount - 1) downTo 0) {
                val child = parent.getChildAt(i)

                // 如果找到gone_layout，移除它
                if (child.id == goneLayoutId) {
                    parent.removeView(child)
                    Xpose


窗口操作。

![AltTab](https://cdn.jsdelivr.net/gh/SHERlocked93/pic@master/uPic/windows-theme-20-53-57.jpg)

良心的是，AltTab 还支持中文 👍，而且是免费，在[这里](https://github.com/lwouis/alt-tab-macos/releases/download/v6.7.3/AltTab-6.7.3.zip)下载应用，也可以 HomeBrew 下载 `brew cask install alt-tab` ，但注意 HomeBrew 下载的并不是最新版本的，所以推介使用前面的链接下载。

## 5. FinalShell

打开后朴素的界面告诉你，这是国内个人开发者开发（或许是钢铁直男？），但功能很全也很实用。

支持多标签、批量管理服务器，登录 SSH 远程并记住配置下次双击直接连 SSH，支持设置自定义快捷命令，自动压缩解压，一大堆皮肤可以自由选择，快捷键可以自定义，sftp 与终端同屏显示，还可以直接拖拽本地的文件夹到 sftp 的文件夹自动传到服务器。

![Finalshell](https://cdn.jsdelivr.net/gh/SHERlocked93/pic@master/uPic/image-20201203201321707-20-13-23.png)

FinalShell 的免费版已经够用了，在[这里](http://www.hostbuf.com/c/131.html)下载，有 Mac 版也有 Win 版。Mac 上可以命令行一键安装：

```bash
curl -L -o finalshell_install.sh www.hostbuf.com/downloads/finalshell_install.sh;chmod +x finalshell_install.sh;sudo ./finalshell_install.sh
```

除此之外还用过挺多 Shell 工具，颜值比较高的有一款 [Termius](https://apps.apple.com/cn/app/termius-ssh-client/id1176074088?mt=12) 也挺不错，但是收费，另外老牌的 XShell 也很推介。

## 6. Keka / The Unarchiver

正如 Windows 上装机必备之一就是解压工具，Mac 上自带的解压缩工具虽然挺好用，但支持的格式不多需要别的软件来补充，这里推介两个很不错的软件，一个主动一个被动，两款都支持中文。

Keka 是主动型的软件，可以压缩也可以解压，压缩支持设置解压密码、分卷压缩、选择压缩格式，支捷键生成压缩包，使用也很方便，在解压的时候直接拖拽到 Dock 的 Keka 图标上，或者使用快捷�


tonSlot*, execbutton->getValue()),
                                       Q_ARG(int, index));

        execbutton->setToolTip(execSlotName);
        updateSlotsScrollArea(0);
    }
}

void AdvanceButtonDialog::performStatsWidgetRefresh(QListWidgetItem *item)
{
    qInstallMessageHandler(MessageHandler::myMessageOutput);

    SimpleKeyGrabberButton *button = item->data(Qt::UserRole).value<SimpleKeyGrabberButton*>();
    JoyButtonSlot *slot = button->getValue();

    if ((slot->getSlotMode() == JoyButtonSlot::JoyKeyboard) && (slot->getSlotCode() != 0))
    {
        ui->slotTypeComboBox->setCurrentIndex(0);
    }
    else if ((slot->getSlotMode() == JoyButtonSlot::JoyMouseButton) ||
        (slot->getSlotMode() == JoyButtonSlot::JoyMouseMovement))
    {
        ui->slotTypeComboBox->setCurrentIndex(0);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyCycle)
    {
        ui->slotTypeComboBox->setCurrentIndex(1);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyDelay)
    {
        ui->slotTypeComboBox->setCurrentIndex(2);

        refreshTimeComboBoxes(slot);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyDistance)
    {
        ui->slotTypeComboBox->setCurrentIndex(3);

        disconnect(ui->distanceSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
                   this, &AdvanceButtonDialog::checkSlotDistanceUpdate);

        ui->distanceSpinBox->setValue(slot->getSlotCode());

        connect(ui->distanceSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
                this, &AdvanceButtonDialog::checkSlotDistanceUpdate);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyHold)
    {
        ui->slotTypeComboBox->setCurrentIndex(5);
        refreshTimeComboBoxes(slot);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyLoadProfile)
    {
        ui->slotTypeComboBox->setCurrentIndex(6);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyMouseSpeedMod)
    {
        ui->slotTypeComboBox->setCurrentIndex(7);
        disconnect(ui->mouseSpeedModSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
                   this, &AdvanceButtonDialog::checkSlotMouseModUpdate);

        ui->mouseSpeedModSpinBox->setValue(slot->getSlotCode());

        connect(ui->mouseSpeedModSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
                this, &AdvanceButtonDialog::checkSlotMouseModUpdate);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyPause)
    {
        ui->slotTypeComboBox->setCurrentIndex(8);
        refreshTimeComboBoxes(slot);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyKeyPress)
    {
        ui->slotTypeComboBox->setCurrentIndex(9);
        refreshTimeComboBoxes(slot);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoyRelease)
    {
        ui->slotTypeComboBox->setCurrentIndex(10);
        refreshTimeComboBoxes(slot);
    }
    else if (slot->getSlotMode() == JoyButtonSlot::JoySetChange)
    {
        disconnect(ui->slotSetChangeComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
                   this, &AdvanceButtonDialog::checkSlotSetChangeUpdate);

        ui->slotTypeComboBox->setCurrentIndex(11);
        int chooseIndex = slot->getSlotCode();
        int foundIndex = ui->slotSetChangeComboBox->findData(QVariant(choose


upfire = class:new()

function upfire:init(x, y, r)
	--PHYSICS STUFF
	self.cox = x
	self.coy = y
	self.starty = self.coy-1
	self.y = mapheight
	self.x = x-14/16

	self.speedy = 0
	self.speedx = 0

	self.width = 12/16
	self.height = 12/16
	self.active = true
	self.static = false
	self.gravity = upfiregravity
	self.autodelete = false

	local v = convertr(r, {"bool"}, true)
	if v[1] ~= nil then
		self.jumpforce = -math.sqrt(2*(self.gravity or yacceleration)*(mapheight-y+1))
		self.ignorelowgravity = true
	else
		self.jumpforce = -upfireforce
	end
	self.delay = 0
	self.category = 31

	self.mask = {	true,
					true, false, true, true, true,
					true, true, true, true, true,
					true, true, true, true, true,
					true, true, true, true, true,
					true, true, true, true, true,
					true, true, true, true, true,
					false}

	--IMAGE STUFF
	self.drawable = true
	self.graphic = upfireimg
	self.quad = upfirequad

	self.offsetX = 6
	self.offsetY = 3
	self.quadcenterX = 8
	self.quadcenterY = 8

	self.light = 2
	self.rotatetowardstrackpath = t


import discord
from discord.ext import commands
import json
import os

class Setup(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.config_path = 'data/report/config.json'

    def save_config(self, guild_id, channel_id):
        """通報チャンネルの設定を保存する"""
        if os.path.exists(self.config_path):
            with open(self.config_path, 'r') as f:
                config = json.load(f)
        else:
            config = {}

        config[str(guild_id)] = {"report_channel": channel_id}

        with open(self.config_path, 'w') as f:
            json.dump(config, f, indent=4)

    @commands.hybrid_command(name='setchannel')
    @commands.has_permissions(administrator=True)
    async def set_channel(self, ctx, channel: discord.TextChannel):
        """通報チャンネルを設定する"""
        self.save_config(ctx.guild.id, channel.id)
        await ctx.send(f'{channel.mention}が通報チャンネルとして設定されました。')

async def setup(bot):
    await bot.add_cog(Setup(bot))


;
	vertical-align: top;
}

.fc-time-grid-event.fc-short .fc-time span {
	display: none; /* don't display the full time text... */
}

.fc-time-grid-event.fc-short .fc-time:before {
	content: attr(data-start); /* ...instead, display only the start time */
}

.fc-time-grid-event.fc-short .fc-time:after {
	content: "\000A0-\000A0"; /* seperate with a dash, wrapped in nbsp's */
}

.fc-time-grid-event.fc-short .fc-title {
	font-size: .85em; /* make the title text the same size as the time */
	padding: 0; /* undo padding from above */
}

/* resizer */

.fc-time-grid-event .fc-resizer {
	position: absolute;
	z-index: 3; /* above content */
	left: 0;
	right: 0;
	bottom: 0;
	height: 8px;
	overflow: hidden;
	line-height: 8px;
	font-size: 11px;
	font-family: monospace;
	text-align: center;
	cursor: s-resize;
}

.fc-time-grid-event .fc-resizer:after {
	content: "=";
}
/*!
 * Bootstrap Reboot v5.3.0 (https://getbootstrap.com/)
 */
:root,
[data-bs-theme=light] {
  --bs-blue: #0d6efd;
  --bs-indigo: #6610f2;
  --bs-purple: #6f42c1;
  --bs-pink: #d63384;
  --bs-red: #dc3545;
  --bs-orange: #fd7e14;
  --bs-yellow: #ffc107;
  --bs-green: #198754;
  --bs-teal: #20c997;
  --bs-cyan: #0dcaf0;
  --bs-black: #000;
  --bs-white: #fff;
  --bs-gray: #6c757d;
  --bs-gray-dark: #343a40;
  --bs-gray-100: #f8f9fa;
  --bs-gray-200: #e9ecef;
  --bs-gray-300: #dee2e6;
  --bs-gray-400: #ced4da;
  --bs-gray-500: #adb5bd;
  --bs-gray-600: #6c757d;
  --bs-gray-700: #495057;
  --bs-gray-800: #343a40;
  --bs-gray-900: #212529;
  --bs-primary: #0d6efd;
  --bs-secondary: #6c757d;
  --bs-success: #198754;
  --bs-info: #0dcaf0;
  --bs-warning: #ffc107;
  --bs-danger: #dc3545;
  --bs-light: #f8f9fa;
  --bs-dark: #212529;
  --bs-primary-rgb: 13, 110, 253;
  --bs-secondary-rgb: 108, 117, 125;
  --bs-success-rgb: 25, 135, 84;
  --bs-info-rgb: 13, 202, 240;
  --bs-warning-rgb: 255, 193, 7;
  --bs-danger-rgb: 220, 53, 69;
  --bs-light-rgb: 248, 249, 250;
  --bs-dark-rgb: 33, 37, 41;
  --bs-primary-text-emphasis: #052c65;
  --bs-secondary-text-emphasis: #2b2f32;
  --bs-success-text-emphasis: #0a3622;
  --bs-info-text-emphasis: #055160;
  --bs-warning-text-emphasis: #664d03;
  --bs-danger-text-emphasis: #58151c;
  --bs-light-text-emphasis: #495057;
  --bs-dark-text-emphasis: #495057;
  --bs-primary-bg-subtle: #cfe2ff;
  --bs-secondary-bg-subtle: #e2e3e5;
  --bs-success-bg-subtle: #d1e7dd;
  --bs-info-bg-subtle: #cff4fc;
  --bs-warning-bg-subtle: #fff3cd;
  --bs-danger-bg-subtle: #f8d7da;
  --bs-light-bg-subtle: #


class="${x => (x.paused ? "paused" : "")}"
    >
        ${when(x => typeof x.value === "number", html `

 x.percentComplete}%"
                    >

            `, html `

                    <slot class="indeterminate" name="indeterminate">
                        ${defintion.indeterminateIndicator1 || ""}
                        ${defintion.indeterminateIndicator2 || ""}
                    </slot>

            `)}
    </template>
`;

;// CONCATENATED MODULE: ../node_modules/@jupyter/web-components/dist/esm/progress/progress.styles.js
// Copyright (c) Jupyter Development Team.
// Copyright (c) Microsoft Corporation.
// Distributed under the terms of the Modified BSD License.

/**
 * Styles for Progress
 * @public
 */
const progressStyles = (context, definition) => css `
    ${display('flex')} :host {
      align-items: center;
      outline: none;
      height: calc(${designUnit} * 1px);
      margin: calc(${designUnit} * 1px) 0;
    }

    .progress {
      background-color: ${neutralFillRest};
      border-radius: calc(${designUnit} * 1px);
      width: 100%;
      height: 100%;
      display: flex;
      align-items: center;
      position: relative;
    }

    .determinate {
      background-color: ${accentForegroundRest};
      border-radius: calc(${designUnit} * 1px);
      height: 100%;
      transition: all 0.2s ease-in-out;
      display: flex;
    }

    .indeterminate {
      height: 100%;
      border-radius: calc(${designUnit} * 1px);
      display: flex;
      width: 100%;
      position: relative;
      overflow: hidden;
    }

    .indeterminate-indicator-1 {
      position: absolute;
      opacity: 0;
      height: 100%;
      background-color: ${accentForegroundRest};
      border-radius: calc(${designUnit} * 1px);
      animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
      width: 40%;
      animation: indeterminate-1 2s infinite;
    }

    .indeterminate-indicator-2 {
      position: absolute;
      opacity: 0;
      height: 100%;
      background-color: ${accentForegroundRest};
      border-radius: calc(${designUnit} * 1px);
      animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
      width: 60%;
      animation: indeterminate-2 2s infinite;
    }

    :host([paused]) .indeterminate-indicator-1,
    :host([paused]) .indeterminate-indicator-2 {
      animation-play-state: paused;
      background-color: ${neutralFillRest};
    }

    :host([paused]) .determinate {
      background-color: ${design_tokens_neutralForegroundHint};
    }

    @keyframes indeterminate-1 {
      0% {
        opacity: 1;
        transform: translateX(-100%);
      }
      70% {
        opacity: 1;
        transform: translateX(300%);
      }
      70.01% {
        opacity: 0;
      }
      100% {
        opacity: 0;
        transform: translateX(300%);
      }
    }

    @keyframes indeterminate-2 {
      0% {
        opacity: 0;
        transform: translateX(-150%);
      }
      29.99% {
        opacity: 0;
      }
      30% {
        opacity: 1;
        transform: translateX(-150%);
      }
      100% {
        transform: translateX(166.66%);


en::new(TokenValue::Minus, span)
    }

    /// Create a new plus token
    #[inline]
    pub(crate) fn plus(span: Span) -> Self {
        Token::new(TokenValue::Plus, span)
    }

    /// Create a new semicolon token
    #[inline]
    pub(crate) fn semicolon(span: Span) -> Self {
        Token::new(TokenValue::Semicolon, span)
    }

    /// Create a new star token
    #[inline]
    pub(crate) fn star(span: Span) -> Self {
        Token::new(TokenValue::Star, span)
    }

    /// Create a new bang token
    #[inline]
    pub(crate) fn bang(span: Span) -> Self {
        Token::new(TokenValue::Bang, span)
    }

    /// Create a new bang-equal token
    #[inline]
    pub(crate) fn bang_equal(span: Span) -> Self {
        Token::new(TokenValue::BangEqual, span)
    }

    /// Create a new equal token
    #[inline]
    pub(crate) fn equal(span: Span) -> Self {
        Token::new(TokenValue::Equal, span)
    }

    /// Create a new equal-equal token
    #[inline]
    pub(crate) fn equal_equal(span: Span) -> Self {
        Token::new(TokenValue::EqualEqual, span)
    }

    /// Create a new less token
    #[inline]
    pub(crate) fn less(span: Span) -> Self {
        Token::new(TokenValue::Less, span)
    }

    /// Create a new less-equal token
    #[inline]
    pub(crate) fn less_equal(span: Span) -> Self {
        Token::new(TokenValue::LessEqual, span)
    }

    /// Create a new greater token
    #[inline]
    pub(crate) fn greater(span: Span) -> Self {
        Token::new(TokenValue::Greater, span)
    }

    /// Create a new greater-equal token
    #[inline]
    pub(crate) fn greater_equal(span: Span) -> Self {
        Token::new(TokenValue::GreaterEqual, span)
    }

    /// Create a new slash token
    #[inline]
    pub(crate) fn slash(span: Span) -> Self {
        Token::new(TokenValue::Slash, span)
    }

    /// Create a new comment token
    #[inline]
    pub(crate) fn comment(c: String, span: Span) -> Self {
        Token::new(TokenValue::Comment(c), span)
    }

    /// Create a new string token
    #[inline]
    pub(crate) fn string(str: String, span: Span) -> Self {
        Token::new(TokenValue::String(str), span)
    }

    /// Create a new number token
    #[inline]
    pub(crate) fn number(n: f64, span: Span) -> Self {
        Token::new(TokenValue::Number(n), span)
    }

    /// Create a whitespace token
    #[inline]
    pub(crate) fn whitespace(ws: String, span: Span) -> Self {
        Token::new(TokenValue::Whitespace(ws), span)
    }

    /// Create a newline token
    #[inline]
    pub(crate) fn newline(span: Span) -> Self {
        Token::new(TokenValue::NewLine, span)
    }

    /// Create a identifier token
    #[inline]
    pub(crate) fn identifier(i: String, span: Span) -> Self {
        Token::new(TokenValue::Ident(i), span)
    }
}

//
// Formatting
//

impl Display for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} ({})", self.tkn_value, self.span)
    }
}

impl Debug for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>


= "狂潮湾",
  [518] = "恐惧海岸",
  [536] = "腐草农场",
  [537] = "火羽山",
  [538] = "拉卡利油沼",
  [539] = "恐惧小道",
  [540] = "巨痕谷",
  [541] = "马绍尔营地",
  [542] = "蘑菇石",
  [543] = "葛拉卡温泉",
  [556] = "洛克湖",
  [576] = "乞丐鬼屋",
  [596] = "科多兽坟场",
  [597] = "幽灵岗哨",
  [598] = "萨瑟里斯海岸",
  [599] = "雷斧堡垒",
  [600] = "波尔甘的洞穴",
  [602] = "玛诺洛克集会所",
  [603] = "萨格隆",
  [604] = "玛格拉姆村",
  [606] = "吉尔吉斯村",
  [607] = "长矛谷",
  [608] = "尼耶尔前哨站",
  [609] = "科尔卡村",
  [616] = "海加尔山",
  [618] = "冬泉谷",
  [636] = "黑狼河",
  [637] = "科多石",
  [638] = "秘道",
  [639] = "灵魂石地",
  [640] = "眠炎圣殿",
  [656] = "月神湖",
  [657] = "避难营",
  [676] = "外域",
  [696] = "工匠区UNUSED",
  [697] = "贸易区UNUSED",
  [698] = "神庙花园UNUSED",
  [699] = "月神殿UNUSED",
  [700] = "Cenarion Enclave UNUSED",
  [701] = "Warrior\'s Terrace UNUSED",
  [702] = "鲁瑟兰村",
  [716] = "铁环营地",
  [717] = "监狱",
  [718] = "哀嚎洞穴",
  [719] = "黑暗深渊",
  [720] = "勇士岛",
  [721] = "诺莫瑞根",
  [722] = "剃刀高地",
  [736] = "班尼希尔山谷",
  [796] = "血色修道院",
  [797] = "杰罗德码头",
  [798] = "山巅之塔",
  [799] = "暗色河滩",
  [800] = "寒脊山小径",
  [801] = "寒风峡谷",
  [802] = "闪光岭",
  [803] = "冻石农场",
  [804] = "冻土岭",
  [805] = "南门小径",
  [806] = "南门哨岗",
  [807] = "北门小径",
  [808]


#pragma once

#include "ofMain.h"
#include "ofxOsc.h"

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

 oscChatSystemExample

 This app demonstrates using the ofxOsc addon to create a simple chat room and
 sends chat messages to a server running in the same app. Optionally, it can
 talk to another instance of this app on another host IP address. To enable
 this, get the IP address of the second computer and set it as the value of the
 clientDesintation in the ofApp.cpp setup() function, as shown in the comment.

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

class ofApp : public ofBaseApp{

	public:
		void setup();
		void update();
		void draw();

		void keyPressed(int key);
		void keyReleased(int key);
		void mouseMoved(int x, int y);
		void mouseDragged(int x, int y, int button);
		void mousePressed(int x, int y, int button);
		void mouseReleased(int x, int y, int button);
		void mouseEntered(int x, int y);
		void mouseExited(int x, int y);
		void windowResized(int w, int h);
		void dragEvent(ofDragInfo dragInfo);
		void gotMessage(ofMessage msg);

		ofTrueTypeFont font; // standard font
		ofTrueTypeFont titleFont; // font for some info in the title line

		//----------------------------------------
		// client side:

		ofxOscSender clientSender; // client sender object
		string clientDestination; // IP address we're sending to
		int clientSendPort; // port we're sending to
		string clientTyping; // what we're going to send: some stuff you typed

		ofxOscReceiver clientReceiver; // OSC receiver
		int clientRecvPort; // port where we listen for messages
		string clientMessages; // string containing the received messages for display

		//----------------------------------------
		// server side:

		ofxOscReceiver serverReceiver; // OSC receiver
		int serverRecvPort; // port we're listening on: must match port from sender!
		string serverTyping; // messages you've received from the clientes

		// message display variables
		vector<string>serverMessages; // vector containing the received messages for display
		unsigned int maxServerMessages; // nr of messages fitting on the screen

		vector<string>knownClients; // collected IP's of chat participants
		ofxOscSender serverSender; // server sender object

		// distribute a received message among the known hosts
		void broadcastReceivedMessage(string chatmessage);

		// parse an OscMessage into a string for easy logging
		string getOscMsgAsString(ofxOscMessage m);
};


],
    "Bio-Technology": [
        "NNP"
    ],
    "Manigat": [
        "NNP"
    ],
    "philanthropic": [
        "JJ"
    ],
    "Brahms": [
        "NNP"
    ],
    "archaism": [
        "NN"
    ],
    "Lube": [
        "NNP"
    ],
    "iridium": [
        "NN"
    ],
    "Fox-Meyer": [
        "NNP"
    ],
    "Mohan": [
        "NNP"
    ],
    "Mrad": [
        "NN"
    ],
    "salvage": [
        "VB",
        "NN"
    ],
    "grenade": [
        "NN"
    ],
    "Buchwald": [
        "NNP"
    ],
    "male-fertile": [
        "JJ"
    ],
    "scorekeepers": [
        "NNS"
    ],
    "overhears": [
        "VBZ"
    ],
    "Jarvik": [
        "NNP"
    ],
    "estate": [
        "NN"
    ],
    "hemoglobin": [
        "NN"
    ],
    "gadgets": [
        "NNS"
    ],
    "more-spontaneous": [
        "JJ"
    ],
    "treasuries": [
        "NNS"
    ],
    "jumble": [
        "NN"
    ],
    "keep": [
        "VB",
        "NN",
        "VBP"
    ],
    "attract": [
        "VB",
        "VBP"
    ],
    "Jarvis": [
        "NNP"
    ],
    "ceremony": [
        "NN"
    ],
    "Haywood": [
        "NNP"
    ],
    "multibank": [
        "NN"
    ],
    "drummed": [
        "VBD",
        "VBN"
    ],
    "finalist": [
        "NN"
    ],
    "drummer": [
        "NN"
    ],
    "Poverty": [
        "NN",
        "NNP"
    ],
    "pro-environment": [
        "NN"
    ],
    "Flemings": [
        "NNP",
        "NNPS"
    ],
    "char-broiled": [
        "JJ"
    ],
    "description": [
        "NN"
    ],
    "first-bracket": [
        "NN"
    ],
    "insecure": [
        "JJ"
    ],
    "befoh": [
        "RB"
    ],
    "astoundingly": [
        "RB"
    ],
    "Stookey": [
        "NNP"
    ],
    "ash-blonde": [
        "JJ"
    ],
    "Wilhelmina": [
        "NNP"
    ],
    "salsa": [
        "NN"
    ],
    "Banners": [
        "NNS"
    ],
    "parallel": [
        "JJ",
        "RB",
        "VB",
        "VBP",
        "NN"
    ],
    "provisionally": [
        "RB"
    ],
    "humiliatingly": [
        "RB"
    ],
    "Quakeress": [
        "NN"
    ],
    "Sadler": [
        "NNP"
    ],
    "hotel-casinos": [
        "NNS"
    ],
    "HEALTHY": [
        "JJ"
    ],
    "amid": [
        "IN"
    ],
    "highpriced": [
        "JJ"
    ],
    "pullout": [
        "NN"
    ],
    "summing": [
        "VBG"
    ],
    "flippantly": [


 avoid collision
	if _, ok := o.ExtraOpts["pubsub"]; !ok {
		o.ExtraOpts["pubsub"] = false
	}
}

func NewIPFSMobile(ctx context.Context, repo *ipfs_mobile.RepoMobile, opts *MobileOptions) (*ipfs_mobile.IpfsMobile, error) {
	opts.fillDefault()

	var p2popts []p2p.Option

	err := repo.ApplyPatchs(func(cfg *ipfs_config.Config) error {
		var err error
		if p2popts, err = opts.IpfsConfigPatch(cfg); err != nil {
			return err
		}

		return nil
	})
	if err != nil {
		return nil, err
	}

	// check that p2p opt is set
	if p2popts == nil {
		return nil, fmt.Errorf("unable p2p option: cannot be nil")
	}

	// configure host
	hostconfig := &ipfs_mobile.HostConfig{
		// called after host init
		ConfigFunc: opts.HostConfigFunc,

		// p2p options
		Options: p2popts,
	}

	// configure routing
	routingconfig := &ipfs_mobile.RoutingConfig{
		// called after host init
		ConfigFunc: opts.RoutingConfigFunc,
	}

	// configure ipfs mobile
	ipfsconfig := ipfs_mobile.IpfsConfig{
		HostConfig:    hostconfig,
		RoutingConfig: routingconfig,
		RepoMobile:    repo,
		ExtraOpts:     opts.ExtraOpts,
		HostOption:    opts.HostOption,
		RoutingOption: opts.RoutingOption,
	}

	return ipfs_mobile.NewNode(ctx, &ipfsconfig)
}

func CustomRoutingOption(mode p2p_dht.ModeOpt, net DHTNetworkMode, opts ...p2p_dht.Option) func(args ipfs_p2p.RoutingOptionArgs) (p2p_routing.Routing, error) {
	return func(args ipfs_p2p.RoutingOptionArgs) (p2p_routing.Routing, error) {
		opts = append(opts,
			p2p_dht.Mode(mode),
			p2p_dht.Datastore(args.Datastore),
			p2p_dht.Validator(args.Validator),
			p2p_dht.BootstrapPeers(args.BootstrapPeers...),
		)

		return newDualDHT(args.Ctx, args.Host, net, opts...)
	}
}

func (o *MobileOptions) defaultIpfsConfigPatch(cfg *ipfs_config.Config) ([]p2p.Option, error) {
	// Imitate berty setupIPFSConfig
	// https://github.com/berty/berty/blob/5a8b9cb8524c1287ab2533a9e186ac8bde7f2b57/go/internal/initutil/ipfs.go#L474C19-L474C34
	p2popts := []libp2p.Option{}

	// make sure relay is enabled
	cfg.Swarm.RelayClient.Enabled = ipfs_cfg.True
	cfg.Swarm.Transports.Network.Relay = ipfs_cfg.True

	// add static relay
	pis, err := ParseAndResolveMaddrs(context.TODO(), o.Logger, o.P2PStaticRelays)
	if err != nil {
		return nil, err
	}
	if len(pis) > 0 {
		peers := make([]peer.AddrInfo, len(pis))
		for i, p := range pis {
			peers[i] = *p
		}

		p2popts = append(p2popts, libp2p.EnableAutoRelayWithStaticRelays(peers))
	}

	// prefill peerstore with known rdvp servers
	peers, err := ParseAndResolveMaddrs(context.TODO(), o.Logger, o.PeerStorePeers)
	if err != nil {
		return nil, err
	}
	for _, p := range peers {
		cfg.Peering.Pee


;display:block;line-height:1.16em;font-size:13px;min-height:1.16em;margin: 0px; ">Until the proper memory is revealed, it'll seem like fantasy or an intricately complex dream.

They would seem absurd to our human minds because we don't know how to transmute water into air or turn gold into lead, which is infinitely more useful than gold.

But that's besides the point.

>>4961436

I had one. Once.

But, that shit was lost long ago and I have adopted a new name. It's from a baby that died at 2 months of age, with a legit SSN. And I made it a dual citizen by finding another baby in the neighboring country that had the same name, roughly the same age.

To be honest, I don't know what my real birthday is. Or who my parents are. If I even had any. My DNA shows signs of genetic tampering only possible in vitro.

>>4961439

Ah, you talked to an Old One.

He touched your noggin and spilled the beans of the Universe, probably because your highness amused him. Those guys are dicks because they k


, c);// lui a1, 28672
  c->daddu(a0, a0, a1);                             // daddu a0, a0, a1
  c->daddiu(v1, v1, 16);                            // daddiu v1, v1, 16
  c->sw(v1, 308, a0);                               // sw v1, 308(a0)
  get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
  c->lwu(t9, 7328, v1);                             // lwu t9, 7328(v1)
  call_addr = c->gprs[t9].du32[0];                  // function call:
  c->sll(v0, ra, 0);                                // sll v0, ra, 0
  // c->jalr(call_addr);                               // jalr ra, t9
  mercneric_convert::execute(c);

  block_44:
  get_fake_spad_addr(v1, cache.fake_scratchpad_data, 0, c);// lui v1, 28672
  c->addiu(a0, r0, 1);                              // addiu a0, r0, 1
  c->lbu(a1, 6760, v1);                             // lbu a1, 6760(v1)
  c->daddiu(a2, s1, 448);                           // daddiu a2, s1, 448
  c->lbu(a3, 6763, v1);                             // lbu a3, 6763(v1)
  bc = c->sgpr64(a1) == 0;                          // beq a1, r0, L42
  c->lqc2(vf1, 0, a2);                              // lqc2 vf1, 0(a2)
  if (bc) {goto block_50;}                          // branch non-likely

  bc = c->sgpr64(a3) == 0;                          // beq a3, r0, L42
  c->vmax_bc(DEST::xyzw, BC::w, vf9, vf0, vf0);     // vmaxw.xyzw vf9, vf0, vf0
  if (bc) {goto block_50;}                          // branch non-likely

  c->sb(a0, 6773, v1);                              // sb a0, 6773(v1)
  c->lqc2(vf10, 7360, v1);                          // lqc2 vf10, 7360(v1)
  c->lqc2(vf11, 7376, v1);                          // lqc2 vf11, 7376(v1)
  c->vmula_bc(DEST::xyzw, BC::z, vf9, vf1);         // vmulaz.xyzw acc, vf9, vf1
  c->lw(a0, 8, a2);                                 // lw a0, 8(a2)
  c->vmadda_bc(DEST::xyzw, BC::x, vf10, vf1);       // vmaddax.xyzw acc, vf10, vf1
  bc = ((s64)c->sgpr64(a0)) < 0;                    // bltz a0, L41
  c->lw(v1, 7348, v1);                              // lw v1, 7348(v1)
  if (bc) {goto block_48;}                          // branch non-likely

  c->vmadd_bc(DEST::xyzw, BC::y, vf1, vf11, vf1);   // vmaddy.xyzw vf1, vf11, vf1
  c->mov128_gpr_vf(a0, vf1);                        // qmfc2.i a0, vf1
  c->pcgtw(a0, r0, a0);                             // pcgtw a0, r0, a0
  c->ppach(a0, r0, a0);                             // ppach a0, r0, a0
  bc =


ize_data, context);
      });
    }
    EmptyQueueAndDelete();
  }

  inline void* Context() {
    return context;
  }

  void CloseHandlesAndMaybeDelete(bool set_closing = false) {
    v8::HandleScope scope(env->isolate);
    if (set_closing) {
      node::Mutex::ScopedLock lock(this->mutex);
      is_closing = true;
      if (max_queue_size > 0) {
        cond->Signal(lock);
      }
    }
    if (handles_closing) {
      return;
    }
    handles_closing = true;
    env->node_env()->CloseHandle(
        reinterpret_cast<uv_handle_t*>(&async),
        [](uv_handle_t* handle) -> void {
          ThreadSafeFunction* ts_fn =
              node::ContainerOf(&ThreadSafeFunction::async,
                                reinterpret_cast<uv_async_t*>(handle));
          v8::HandleScope scope(ts_fn->env->isolate);
          ts_fn->env->node_env()->CloseHandle(
              reinterpret_cast<uv_handle_t*>(&ts_fn->idle),
              [](uv_handle_t* handle) -> void {
                ThreadSafeFunction* ts_fn =
                    node::ContainerOf(&ThreadSafeFunction::idle,
                                      reinterpret_cast<uv_idle_t*>(handle));
                ts_fn->Finalize();
              });
        });
  }

  // Default way of calling into JavaScript. Used when ThreadSafeFunction is
  //  without a call_js_cb_.
  static void CallJs(napi_env env, napi_value cb, void* context, void* data) {
    if (!(env == nullptr || cb == nullptr)) {
      napi_value recv;
      napi_status status;

      status = napi_get_undefined(env, &recv);
      if (status != napi_ok) {
        napi_throw_error(env, "ERR_NAPI_TSFN_GET_UNDEFINED",
            "Failed to retrieve undefined value");
        return;
      }

      status = napi_call_function(env, recv, cb, 0, nullptr, nullptr);
      if (status != napi_ok && status != napi_pending_exception) {
        napi_throw_error(env, "ERR_NAPI_TSFN_CALL_JS",
            "Failed to call JS callback");
        return;
      }
    }
  }

  static void IdleCb(uv_idle_t* idle) {
    ThreadSafeFunction* ts_fn =
        node::ContainerOf(&ThreadSafeFunction::idle, idle);
    ts_fn->DispatchOne();
  }

  static void AsyncCb(uv_async_t* async) {
    ThreadSafeFunction* ts_fn =
        node::ContainerOf(&ThreadSafeFunction::async, async);
    CHECK_EQ(0, uv_idle_start(&ts_fn->idle, IdleCb));
  }

  static void Cleanup(void* data) {
    reinterpret_cast<ThreadSafeFunction*>(data)
        ->CloseHandlesAndMaybeDelete(true);
  }

 private:
  // These are variables protected by the mutex.
  node::Mutex mutex;
  std::unique_ptr<node::ConditionVariable> cond;
  std::queue<void*> queue;
  uv_async_t async;
  uv_idle_t idle;
  size_t thread_count;
  bool is_closing;

  // These are variables set once, upon creation, and then never again, which
  // means we don't need the mutex to read them.
  void* context;
  size_t max_queue_size;

  // These are variables accessed only from the loop thread.
  v8impl::Persistent<v8::Function> ref;
  node_napi_env env;
  void* finalize_data;
  napi_finalize finalize_cb;
  napi_threadsafe_function_call_js call_js_cb;
  bool handles_closing;
};

}  // end of anonymous namespace

}  // end of name


/*
 * Copyright (C) 2011 Pengutronix
 * Wolfram Sang <w.sang@pengutronix.de>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 2 as published by the
 * Free Software Foundation.
 */
#include <asm/sizes.h>
#include <mach/mx28.h>
#include <mach/devices-common.h>

#define mxs_i2c_data_entry_single(soc, _id)				\
	{								\
		.id = _id,						\
		.iobase = soc ## _I2C ## _id ## _BASE_ADDR,		\
		.errirq = soc ## _INT_I2C ## _id ## _ERROR,		\
		.dmairq = soc ## _INT_I2C ## _id ## _DMA,		\
	}

#define mxs_i2c_data_entry(soc, _id)					\
	[_id] = mxs_i2c_data_entry_single(soc, _id)

#ifdef CONFIG_SOC_IMX28
const struct mxs_mxs_i2c_data mx28_mxs_i2c_data[] __initconst = {
	mxs_i2c_data_entry(MX28, 0),
	mxs_i2c_data_entry(MX28, 1),
};
#endif

struct platform_device *__init mxs_add_mxs_i2c(
		const struct mxs_mxs_i2c_data *data)
{
	struct resource res[] = {
		{
			.start = data->iobase,
			.end = data->iobase + SZ_8K - 1,
			.flags = IORESOURCE_MEM,
		}, {
			.start = data->errirq,
			.end = data->errirq,
			.flags = IORESOURCE_IRQ,
		}, {
			.start = data->dmairq,
			.end = data->dmairq,
			.flags = IORESOURCE_IRQ,
		},
	};

	return mxs_add_platform_device("mxs-i2c", data->id, res,
					ARRAY_SIZE(res), NULL, 0);
}


Cell, Sudoku } from "./types";

export function fromString(str: string): Cell[][] {
    const cells: Cell[][] = [];
    for (let i = 0; i < 9; i++) {
        const row: Cell[] = [];
        for (let j = 0; j < 9; j++) {
            const val = str[i*9 + j];

            row.push({
                value: val === '.' ? undefined : parseInt(val),
                wrong: false,
                editable: val === '.',
                notes: []
            });
        }
        cells.push(row);
    }

    return cells;
}

export function toString(cells: Cell[][]): string {
    let str = '';

    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            str += cells[i][j].value === undefined ? '.' : `${cells[i][j].value}`;
        }
    }

    return str;
}

const localStorageKey = 'sudokus';

export function getSudokus(): Sudoku[] {
    const store = localStorage.getItem(localStorageKey);
    let val: Sudoku[];
    if (store) {
        val = JSON.parse(store);
    } else {
        val = [];
    }
    return val;
}

function saveSudokus(sudokus: Sudoku[]) {
    localStorage.setItem(localStorageKey, JSON.stringify(sudokus));
}

function genId(sudokus: Sudoku[]) {
    if (sudokus.length === 0) {
        return 0;
    } else {
        return sudokus[sudokus.length - 1].id + 1;
    }
}

export function newSudoku(cells: Cell[][]): number {
    const sudokus = getSudokus();

    const sudoku = {
        id: genId(sudokus),
        cells,
        time: 0,
        solved: false
    }

    sudokus.push(sudoku);

    saveSudokus(sudokus);

    return sudoku.id;
}

export function saveSudoku(sudoku: Sudoku) {
    const sudokus = getSudokus();

    for (let i = 0; i < sudokus.length; i++) {
        if (sudokus[i].id == sudoku.id) {
            sudokus[i] = sudoku;
            break;
        }
    }

    saveSudokus(sudokus);
}

export function getSudoku(id: number): Sudoku | undefined {
    const sudokus = getSudokus();

    for (let i = 0; i < sudokus.length; i++) {
        console.log(sudokus[i], id);
        if (sudokus[i].id == id) {
            return sudokus[i];
        }
    }

    return undefined;
}

export function deleteSudoku(id: number): Sudoku[] {
    const sudokus = getSudokus();

    for (let i = 0; i < sudokus.length; i++) {
        if (sudokus[i].id == id) {
            sudokus.splice(i, 1);
            break;
        }
    }

    saveSudokus(sudokus);

    return sudokus;
}

export function copySudoku(id: number): Sudoku[] {
    const sudokus = getSudokus();

    for (let i = 0; i < sudokus.length; i++) {
        if (sudokus[i].id == id) {
            const copy = {
                id: genId(sudokus),
                cells: sudokus[i].cells,
                time: sudokus[i].time,
                solved: sudokus[i].solved
            };
            sudokus.push(copy);
            break;
        }
    }

    saveSudokus(sudokus);

    return getSudokus();
}import {isEqual} from "./utils/object-compare";
import {jsonObject, jsonMember, jsonArrayMember, TypedJSON} from "../src/typedjson";

interface Point {
    x: number;
    y: number;
}

@


() -> u32 {
    static mut ID: u32 = 0;
    unsafe {
        ID += 1;
        ID
    }
}

fn is_in_map(x: i32, y: i32, w: i32, h: i32) -> bool {
    if x < 0 || y < 0 || x >= w || y >= h {
        false
    }
    else {
        true
    }
}

fn squared_distance(x1: i32, y1: i32, x2: i32, y2: i32) -> i32 {
    (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
}

pub fn puppet_master(level: &mut Level, play_log: &mut Vec<String>) {

    let mut occupied_cell: HashMap<u32, (i32, i32)> = HashMap::new();
    // Clone is an expensive method... For the moment, it's not useful...
    //let player = level.entities[0].clone();

    //... So just take the useful values
    let player_x = level.entities[0].x;
    let player_y = level.entities[0].y;

    // Behavior resolution
    for entity in level.entities.iter_mut() {
        match entity.behavior {
            Behavior::Drunk => {
                entity.action = drunk_walking();
            },
            Behavior::Sleep => {

                // we need to deference player data before use
                if squared_distance(entity.x, entity.y, player_x, player_y) < 9 {
                    entity.behavior = Behavior::Drunk
                }
            },
            _ =>{},

        }

        occupied_cell.insert(entity.id, (entity.x, entity.y));
    }

    // Action resolution
    for entity in level.entities.iter_mut() {
        match entity.action {
            Action::Move(dx, dy) => {
                let new_x = entity.x + dx;
                let new_y = entity.y + dy;

                if is_in_map(new_x, new_y, level.width, level.height) && level.level_map[((entity.x + dx) + (entity.y + dy) * level.width) as usize].crossable {
                    // if crossable, we need to check if cell is occupied by another living entity
                    let not_allowed = occupied_cell.iter().any(|cell|  cell.1.0 == new_x && cell.1.1 == new_y);  // Erk !! It's ugly
                    if !not_allowed {
                        entity.move_entity(dx, dy);

                        // Occupied cell hashmap updating with the new position
                        occupied_cell.insert(entity.id, (new_x, new_y));
                    }
                }

                entity.action = Action::Waiting;
            },
            Action::Pick => {
                let item_position = level.items.iter().position(|item| item.x == entity.x && item.y == entity.y);
                match item_position {
                    Some(pos) => {
                        // Message in log
                        play_log[0] = level.items[pos].description.clone();
                        let pick_ok = entity.add_to_inventory(level.items[pos].clone());
                        if pick_ok {
                            level.items.remove(pos);
                        }
                    },
                    None => {
                        play_log[0] = "Nothing to pick up !".to_string();
                    }
                }
            }
            _ => {}
        }
        // Fov calculation only for the Hero
        if entity.nature == EntityType::Hero {
            level.in_fov = fov


vé pour les soins", an);
            return;
          }
          if (soinsImpossible.has(an[1])) {
            nonSoignable += ds;
          } else {
            if (ds > soinsSuivis) {
              evt.attributes = evt.attributes || [];
              evt.attributes.push({
                attribute: a,
                current: ds
              });
              ds -= soinsSuivis;
              a.set('current', ds);
              soinsSuivis = 0;
            } else {
              soinsSuivis -= ds;
              ds = 0;
            }
          }
        } else ds = 0;
        if (ds === 0) {
          evt.deletedAttributes = evt.deletedAttributes || [];
          evt.deletedAttributes.push(a);
          a.remove();
        }
      }
    });
    pvmax -= nonSoignable;
    if (bar1 === 0) {
      if (attributeAsBool(perso, 'etatExsangue')) {
        removeTokenAttr(perso, 'etatExsangue', evt, "retrouve des couleurs");
      }
    }
    if (charAttributeAsBool(perso, 'vieArtificielle')) {
      soins = Math.floor(soins / 2);
    }
    bar1 += soins;
    var soinsEffectifs = soins;
    if (bar1 > pvmax) {
      if (attributeAsBool(perso, 'formeDArbre')) {
        var apv = tokenAttribute(perso, 'anciensPV');
        if (apv.length > 0) {
          apv = apv[0];
          var anciensPV = parseInt(apv.get('current'));
          var anciensMax = parseInt(apv.get('max'));
          if (!(isNaN(anciensPV) || isNaN(anciensMax)) &&
            anciensPV < anciensMax) {
            var soinsTransferes = bar1 - pvmax;
            if (anciensMax - anciensPV < soinsTransferes)
              soinsTransferes = anciensMax - anciensPV;
            anciensPV += soinsTransferes;
            bar1 -= soinsTransferes;
            setTokenAttr(perso, 'anciensPV', anciensPV, evt, undefined, anciensMax);
          }
        }
      }
      // On  cherche si il y a des DM temporaires à soigner
      if (bar1 > pvmax) {
        var hasMana = (ficheAttributeAsInt(perso, 'PM', 0) > 0);
        var dmgTemp;
        if (hasMana) dmgTemp = attributeAsInt(perso, 'DMTEMP', 0);
        else {
          dmgTemp = parseInt(token.get('bar2_value'));
          if (isNaN(dmgTemp)) dmgTemp = 0;
        }
        if (dmgTemp > 0) {
          var newDmgTemp = dmgTemp - bar1 + pvmax;
          if (newDmgTemp < 0) {
            newDmgTemp = 0;
            bar1 -= dmgTemp;
          } else bar1 = pvmax;
          if (hasMana) setTokenAttr(perso, 'DMTEMP', newDmgTemp, evt);
          else updateCurrentBar(token, 2, newDmgTemp, evt);
        }
        soinsEffectifs -= (bar1 - pvmax);
        bar1 = pvmax;
      }
    }
    if (updateBar1) updateCurrentBar(token, 1, bar1, evt);
    if (soinsEffectifs > 0) {
      if (callTrue) callTrue(soinsEffectifs);
    } else {
      if (callMax) callMax();
    }
  }

  function setState(personnage, etat, value, evt) {
    var token = personnage.token;
    var charId


n is enabled if
	PxConstraintFlag::ePROJECTION is set for the joint.

	If the joint deviates by more than this angle around its locked angular degrees of freedom,
	the solver will move the bodies to close the angle.

	Setting a very small tolerance may result in simulation jitter or other artifacts.

	Sometimes it is not possible to project (for example when the joints form a cycle).

	Range: [0,Pi]

	Default: Pi

	\param[in] tolerance the angular tolerance threshold in radians

	@see getProjectionAngularTolerance() PxJoint::setConstraintFlag() PxConstraintFlag::ePROJECTION
	*/

	virtual void				setProjectionAngularTolerance(PxReal tolerance)					= 0;

	/**
	\brief gets the angular tolerance threshold for projection.

	\return the angular tolerance threshold in radians

	@see setProjectionAngularTolerance()
	*/

	virtual PxReal				getProjectionAngularTolerance()			const					= 0;

	/**
	\brief Returns string name of PxRevoluteJoint, used for serialization
	*/
	virtual	const char*			getConcreteTypeName() const { return "PxRevoluteJoint"; }

protected:

	//serialization

	/**
	\brief Constructor
	*/
	PX_INLINE					PxRevoluteJoint(PxType concreteType, PxBaseFlags baseFlags) : PxJoint(concreteType, baseFlags) {}

	/**
	\brief Deserialization constructor
	*/
	PX_INLINE					PxRevoluteJoint(PxBaseFlags baseFlags) : PxJoint(baseFlags) {}

	/**
	\brief Returns whether a given type name matches with the type of this instance
	*/
	virtual	bool				isKindOf(const char* name) const { return !::strcmp("PxRevoluteJoint", name) || PxJoint::isKindOf(name); }

	//~serialization
};

#if !PX_DOXYGEN
} // namespace physx
#endif

/** @} */
#endif


 Service {
    fn inc(&self);
    fn get(&self) -> i32;
}

struct SimpleA {
    recursion_count: u32,
}

impl SimpleA {
    pub fn new() -> Self {
        Self { recursion_count: 0 }
    }

    pub fn with_recursion_count(recursion_count: u32) -> Self {
        Self { recursion_count }
    }
}

impl A for SimpleA {
    fn service_object_as_argument(&self, b: ServiceRef<dyn B>) {
        let b: Box<dyn B> = b.unwrap_import().into_proxy();
        assert_eq!(0, b.get());
        b.inc();
        b.inc();
        b.inc();
        assert_eq!(3, b.get());
    }

    fn service_object_as_return(&self) -> ServiceRef<dyn B> {
        let b = Box::new(SimpleB::new()) as Box<dyn B>;
        ServiceRef::Export(ServiceToExport::new(b))
    }

    fn recursive_service_object(&self) -> ServiceRef<dyn A> {
        let a = Box::new(SimpleA::with_recursion_count(self.recursion_count + 1)) as Box<dyn A>;
        ServiceRef::Export(ServiceToExport::new(a))
    }

    fn get_recursion_count(&self) -> u32 {
        self.recursion_count
    }
}

impl Service for SimpleA {}

struct SimpleB {
    count: Mutex<i32>,
}

impl SimpleB {
    pub fn new() -> Self {
        Self {
            count: Mutex::new(0),
        }
    }
}

impl Service for SimpleB {}
impl B for SimpleB {
    fn inc(&self) {
        *self.count.lock().unwrap() += 1
    }
    fn get(&self) -> i32 {
        *self.count.lock().unwrap()
    }
}

fn init_logger() {
    let _ = env_logger::builder().is_test(true).try_init();
}

fn create_proxy_a(port: Arc<dyn Port>) -> Arc<dyn A> {
    let a: Arc<dyn A> = Arc::new(SimpleA::new());
    let handle = port.register_service(a.into_skeleton().raw);
    ImportProxy::import_proxy(Arc::downgrade(&port), handle)
}

#[test]
fn service_object_as_return() {
    init_logger();

    let port = Arc::new(TestPort::new());
    let proxy_a = create_proxy_a(port.clone());

    let proxy_b: Box<dyn B> = proxy_a
        .service_object_as_return()
        .unwrap_import()
        .into_proxy();
    assert_eq!(proxy_b.get(), 0);
    proxy_b.inc();
    assert_eq!(proxy_b.get(), 1);
    proxy_b.inc();
    assert_eq!(proxy_b.get(), 2);

    drop(proxy_a);
    drop(proxy_b);
    drop(port)
}

#[test]
fn service_object_as_argument() {
    init_logger();

    let port = Arc::new(TestPort::new());
    let proxy_a = create_proxy_a(port.clone());

    let service_object_b = Box::new(SimpleB::new()) as Box<dyn B>;
    proxy_a.service_object_as_argument(ServiceRef::Export(ServiceToExport::new(service_object_b)));

    drop(proxy_a);
    drop(port)
}

#[test]
fn recursive_service_object() {
    init_logger();

    let port = Arc::new(TestPort::new());
    let mut proxy_a = create_proxy_a(port.clone());
    let mut proxy_as = Vec::new();
    proxy_as.push(Arc::clone(&proxy_a));

    for i in 0..10 {
        assert_eq!(proxy_a.get_recursion_count(), i);
        proxy_a = proxy_a
            .recursive_service_object()
            .unwrap_import()
            .into_proxy();


t(
        ctx,
        'compat/import_export/three_records.db',
      );
      // Put 3 first to test order
      await store.record(3).put(db, 'ho');
      await store.record(1).put(db, 'hu');
      await store.record(2).put(db, 'ha');

      await checkExportImport(db, {
        'sembast_export': 1,
        'version': 1,
        'stores': [
          {
            'name': '_main',
            'keys': [1, 2, 3],
            'values': ['hu', 'ha', 'ho'],
          },
        ],
      });
      await checkExportImportLines(db, [
        {'sembast_export': 1, 'version': 1},
        {'store': '_main'},
        [1, 'hu'],
        [2, 'ha'],
        [3, 'ho'],
      ]);
    });

    test('1_map_record', () async {
      final db = await setupForTest(
        ctx,
        'compat/import_export/1_map_record.db',
      );

      var store = intMapStoreFactory.store();
      await store.record(1).put(db, {'test': 2});

      await checkExportImport(db, {
        'sembast_export': 1,
        'version': 1,
        'stores': [
          {
            'name': '_main',
            'keys': [1],
            'values': [
              {'test': 2},
            ],
          },
        ],
      });
    });

    test('1_map_record_with_all_types', () async {
      final db = await setupForTest(
        ctx,
        'compat/import_export/1_map_record_with_all_types.db',
      );

      var store = stringMapStoreFactory.store();
      await store.record('my_key').put(db, {
        'my_bool': true,
        'my_date': Timestamp(123456789012, 567891000),
        'my_int': 1,
        'my_double': 1.5,
        'my_blob': Blob(Uint8List.fromList([1, 2, 3])),
        'my_string': 'some text',
        'my_list': [4, 5, 6],
        'my_map': {'sub': 73},
        'my_complex': [
          {
            'sub': [
              {
                'inner': [7, 8, 9],
              },
            ],
          },
        ],
      });

      await checkExportImport(db, {
        'sembast_export': 1,
        'version': 1,
        'stores': [
          {
            'name': '_main',
            'keys': ['my_key'],
            'values': [
              {
                'my_bool': true,
                'my_date': {'@Timestamp': '5882-03-11T00:30:12.567891Z'},
                'my_int': 1,
                'my_double': 1.5,
                'my_blob': {'@Blob': 'AQID'},
                'my_string': 'some text',
                'my_list': [4, 5, 6],
                'my_map': {'sub': 73},
                'my_complex': [
                  {
                    'sub': [
                      {
                        'inner': [7, 8, 9],
                      },
                    ],
                  },
                ],
              },
            ],
          },
        ],
      });
      await checkExportImportLines(db, [
        {'sembast_export': 1, 'version': 1},
        {'store': '_main'},
        [
          'my_key',
          {
            'my_bool': true,
            'my_date': {'@Timestamp': '5882-03-11T00:30:12.567891Z'},
            'my_int': 1,
            'my_double': 1.5,
            'my_blob': {'@Blob': 'AQID'},
            'my_


 ChoGGi_Funcs.Menus.SetDroneMoveSpeed(action)
	if not action then
		return
	end

	local speed = action.setting_speed
	local title = action.setting_title

	local ScaleStat = const.Scale.Stat
	local default_setting = ChoGGi.Consts[speed]
	local UpgradedSetting
	if speed == "SpeedDrone" then
		UpgradedSetting = ChoGGi_Funcs.Common.GetResearchedTechValue("SpeedDrone")
	end
	local item_list = {
		{text = Translate(1000121--[[Default]]) .. ": " .. (default_setting / ScaleStat), value = default_setting, hint = T(302535920000889--[[base speed]])},
		{text = 2, value = 2 * ScaleStat, hint = "2000"},
		{text = 3, value = 3 * ScaleStat, hint = "3000"},
		{text = 4, value = 4 * ScaleStat, hint = "4000"},
		{text = 5, value = 5 * ScaleStat, hint = "5000"},
		{text = 10, value = 10 * ScaleStat, hint = "10000"},
		{text = 15, value = 15 * ScaleStat, hint = "15000"},
		{text = 25, value = 25 * ScaleStat, hint = "25000"},
		{text = 50, value = 50 * ScaleStat, hint = "50000"},
		{text = 100, value = 100 * ScaleStat, hint = "100000"},
		{text = 1000, value = 1000 * ScaleStat, hint = "100000"},
		{text = 10000, value = 10000 * ScaleStat, hint = "10000000"},
	}

	-- only reg drones have upgraded speed tech (i think)
	if UpgradedSetting and default_setting ~= UpgradedSetting then
		table.insert(item_list, 2, {text = Translate(302535920000890--[[Upgraded]]) .. ": " .. (UpgradedSetting / ScaleStat), value = UpgradedSetting, hint = T(302535920000891--[[apply tech unlocks]])})
	end

	local hint = UpgradedSetting or default_setting
	if UpgradedSetting then
		if ChoGGi.UserSettings.SpeedDrone then
			hint = ChoGGi.UserSettings.SpeedDrone
		end
	else
		if ChoGGi.UserSettings.SpeedWaspDrone then
			hint = ChoGGi.UserSettings.SpeedWaspDrone
		end
	end

	local function CallBackFunc(choice)
		if choice.nothing_selected then
			return
		end
		choice = choice[1]

		local value = choice.value
		if type(value) == "number" then
			local objs = GetCityLabels("Drone")

			if UpgradedSetting then
				for i = 1, #objs do
					local obj = objs[i]
					if not obj:IsKindOf("FlyingDrone") then
						obj:SetBase("move_speed", value)
					end
				end
				ChoGGi_Funcs.Common.SetSavedConstSetting("SpeedDrone", value)
			else
				for i = 1, #objs do
					local obj = objs[i]
					if obj:IsKindOf("FlyingDrone") then
						obj:SetBase("move_speed", value)
					end
				end
				ChoGGi_Funcs.Common.SetSavedConstSetting("SpeedWaspDrone", value)
			end

			ChoGGi_Funcs.Settings.WriteSettings()
			MsgPopup(
				ChoGGi_Funcs.Common.SettingState(choice.text),
				title
			)
		end
	end

	ChoGGi_Funcs.Common.OpenInListChoice{
		callback = CallBackFunc,
		items = item_list,
		title = title,
		hint = T(302535920000106--[[Current]]) .. ": " .. hint .. "\n\n"
			.. T(302535920001085--[[Setting speed to a non integer (e.g 2.5) crashes the game!]]),
		skip_sort = true,
	}
end

function ChoGGi_Funcs.Menus.SetDroneAmountDrone


2013年12月7日 《国务院关于修改部分行政法规的决定》修订

2017年12月26日 中华人民共和国国务院令第696号修订

<!-- INFO END -->

## 第一章 总则

第一条 为了加强对食盐的管理，保障食盐科学加碘工作的有效实施，确保食盐质量安全和供应安全，保护公民的身体健康，制定本办法。

第二条 国家实行食盐专营管理。

本办法所称食盐，是指直接食用和制作食品所用的盐。

第三条 本办法适用于中华人民共和国境内的食盐生产、销售和储备活动。

第四条 国务院盐业主管部门主管全国盐业工作，负责管理全国食盐专营工作。县级以上地方人民政府确定的盐业主管部门负责管理本行政区域的食盐专营工作。

国务院食品药品监督管理部门负责全国食盐质量安全监督管理。县级以上地方人民政府确定的食盐质量安全监督管理部门负责本行政区域的食盐质量安全监督管理。

第五条 盐业主管部门应当加强对工业用盐等非食用盐的管理，防止非食用盐流入食盐市场。

第六条 国务院盐业主管部门应当会同有关部门加强对食盐生产、批发企业及其董事、监事、高级管理人员的信用管理，建立健全信用信息记录、公示制度，提高食盐行业信用水平。

第七条 依法成立的盐业行业组织依照法律、行政法规和章程，保护企业合法权益，加强行业自律，促进企业守法、诚信经营，引导企业公平竞争。

## 第二章 食盐生产

第八条 国家实行食盐定点生产制度。非食盐定点生产企业不得生产食盐。

第九条 省、自治区、直辖市人民政府盐业主管部门按照统一规划、合理布局的要求审批确定食盐定点生产企业，颁发食盐定点生产企业证书，及时向社会公布食盐定点生产企业名单，并报国务院盐业主管部门备案。

第十条 食


", "connection")
	ticker := time.NewTicker(30 * time.Second)
	defer ticker.Stop()

	// Collect initial metrics
	stats := m.pool.Stat()
	metrics.UpdateConnectionMetrics(
		"postgresql",
		int(stats.AcquiredConns()),
		int(stats.IdleConns()),
		int(stats.MaxConns()),
	)
	log.Log.Info("Initial connection metrics collected",
		"active", stats.AcquiredConns(),
		"idle", stats.IdleConns(),
		"max", stats.MaxConns())

	for {
		select {
		case <-m.ctx.Done():
			logger.Info("Connection metrics collection stopped")
			return
		case <-ticker.C:
			stats := m.pool.Stat()
			metrics.UpdateConnectionMetrics(
				"postgresql",
				int(stats.AcquiredConns()),
				int(stats.IdleConns()),
				int(stats.MaxConns()),
			)
			log.Log.Info("Connection metrics updated",
				"active", stats.AcquiredConns(),
				"idle", stats.IdleConns(),
				"max", stats.MaxConns())
		}
	}
}

// collectContentMetrics periodically collects database content metrics
func (m *metricsPostgresDAGManager) collectContentMetrics() {
	logger := log.FromContext(m.ctx).WithName("metrics").WithValues("type", "content")
	ticker := time.NewTicker(60 * time.Second) // Collect every minute
	defer ticker.Stop()

	// Collect initial metrics
	m.updateContentMetrics(logger)

	for {
		select {
		case <-m.ctx.Done():
			logger.Info("Content metrics collection stopped")
			return
		case <-ticker.C:
			m.updateContentMetrics(logger)
		}
	}
}

// updateContentMetrics collects and updates database content metrics
func (m *metricsPostgresDAGManager) updateContentMetrics(logger logr.Logger) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// Collect DAG metrics grouped by namespace
	rows, err := m.pool.Query(ctx, `
		SELECT
			namespace,
			COUNT(CASE WHEN active = true AND suspended = false THEN 1 END) as active,
			COUNT(CASE WHEN active = true AND suspended = true THEN 1 END) as suspended,
			COUNT(CASE WHEN active = false THEN 1 END) as inactive
		FROM DAGs
		GROUP BY namespace
	`)

	if err != nil {
		logger.Error(err, "Failed to collect DAG metrics")
		metrics.RecordErrorMetrics("postgresql", "collect_content_metrics", "dag_counts_error")
		return
	}
	defer rows.Close()

	// Process each namespace's DAG counts
	for rows.Next() {
		var namespace string
		var active, suspended, inactive int

		if err := rows.Scan(&namespace, &active, &suspended, &inactive); err != nil {
			logger.Error(err, "Failed to scan DAG metrics row")
			metrics.RecordErrorMetrics("postgresql", "collect_content_metrics", "dag_scan_error")
			continue
		}

		log.Log.Info("DAG metrics collected", "namespace", namespace, "active", active, "suspended", suspended, "inactive", inactive)

		dagCounts := map[string]int{
			"active":    active,
			"suspended": suspended,
			"inactive":  inactive,
		}

		// Collect DAG run metrics for this namespace
		var runningRuns, successRuns, failedRuns, pendingRuns int
		dagRunErr := m.pool.QueryRow(ctx, `
			SELECT
				COUNT(CASE WHEN dr.status = 'running' THEN 1 END) as running,
				COUNT(CASE WHEN dr.status = 'success' THEN 1 END) as success,
				COUNT(CASE WHEN dr.status = 'failed' THEN 1 END) as failed,
				COUNT(CASE WHEN dr.status = 'pending' THEN 1 END) as pending
			FROM DAG_Runs dr
			JOIN DAGs d ON dr.dag_id


,
[57442] = {"邪恶魔丝虫",nil},
[57443] = {"前往大漩涡",nil},
[57444] = {"翔龙骑士",nil},
[57445] = {"作战翔龙",nil},
[57446] = {"暗夜精灵幻像",nil},
[57447] = {"暗夜精灵幻像",nil},
[57456] = {"Four Winds Clifftop",nil},
[57457] = {"沮丧的朱家戒卫",nil},
[57458] = {"暗影蝠",nil},
[57459] = {"“重拳”格林·细脚",nil},
[57460] = {"斯多普先生",nil},
[57464] = {"Hozen Hanging Bunny",nil},
[57465] = {"狒狒村恶猴",nil},
[57466] = {"狒狒村火贼",nil},
[57467] = {"金色鲤鱼",nil},
[57470] = {"一捆炸药",nil},
[57473] = {"生命守卫",nil},
[57474] = {"时光守卫",nil},
[57475] = {"梦境守卫",nil},
[57476] = {"Crossing Rocks Credit",nil},
[57477] = {"The Emperor Credit",nil},
[57478] = {"隐形的潜伏者",nil},
[57479] = {"腐蚀寄生虫",nil},
[57480] = {"腐蚀寄生虫触须",nil},
[57482] = {"温度信号",nil},
[57617] = {"李·日光",nil},
[57618] = {"钧·铁息",nil},
[57619] = {"程·晨勉","寺院学者"},
[57620] = {"木艺师大伟",nil},
[57621] = {"任茶师",nil},
[57622] = {"莲华·雷锤","铁匠"},
[57623] = {"沈·石锲",nil},
[57624] = {"于·甘风",nil},
[57625] = {"Generic Sparkle Bunny (CSA)",nil},
[57626] = {"跳下梅花桩",nil},
[57627] = {"荧光莲花",nil},
[57628] = {"乌克乌克",nil},
[57629] = {"低空跳伞伞包",nil},
[57630] = {"低空跳伞伞包",nil},
[57631] = {"Deathwing Vehicle Bunny",nil},
[57632] = {"赤红的生命缚誓者",nil},
[57634] = {"熊猫人木桶",nil},
[57635] = {"丝茧",nil},
[57636] = {"一堆芦笛",nil},
[57638] = {"乔乔·铁眉",nil},
[57648] = {"灭蛾战士",nil},
[57649] = {"悲泣恐魔",nil},
[57662] = {"困在桶里的熊猫人",nil},
[57667] = {"一堆竹板",nil},
[57668] = {"一堆木块",nil},
[57669] =


(var_2461) = &input.filters {
        let mut list_2463 = scope_2460.start_list(true, Some("Filter"));
        for item_2462 in var_2461 {
            #[allow(unused_mut)]
            let mut entry_2464 = list_2463.entry();
            crate::query_ser::serialize_structure_crate_model_filter(entry_2464, item_2462);
        }
        list_2463.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2465 = writer.prefix("KeyName");
    if let Some(var_2466) = &input.key_names {
        let mut list_2468 = scope_2465.start_list(true, Some("KeyName"));
        for item_2467 in var_2466 {
            #[allow(unused_mut)]
            let mut entry_2469 = list_2468.entry();
            entry_2469.string(item_2467);
        }
        list_2468.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2470 = writer.prefix("KeyPairId");
    if let Some(var_2471) = &input.key_pair_ids {
        let mut list_2473 = scope_2470.start_list(true, Some("KeyPairId"));
        for item_2472 in var_2471 {
            #[allow(unused_mut)]
            let mut entry_2474 = list_2473.entry();
            entry_2474.string(item_2472);
        }
        list_2473.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2475 = writer.prefix("DryRun");
    if let Some(var_2476) = &input.dry_run {
        scope_2475.boolean(*var_2476);
    }
    writer.finish();
    Ok(smithy_http::body::SdkBody::from(out))
}

pub fn serialize_operation_crate_operation_describe_launch_templates(
    input: &crate::input::DescribeLaunchTemplatesInput,
) -> Result<smithy_http::body::SdkBody, std::convert::Infallible> {
    let mut out = String::new();
    #[allow(unused_mut)]
    let mut writer =
        smithy_query::QueryWriter::new(&mut out, "DescribeLaunchTemplates", "2016-11-15");
    #[allow(unused_mut)]
    let mut scope_2477 = writer.prefix("DryRun");
    if let Some(var_2478) = &input.dry_run {
        scope_2477.boolean(*var_2478);
    }
    #[allow(unused_mut)]
    let mut scope_2479 = writer.prefix("LaunchTemplateId");
    if let Some(var_2480) = &input.launch_template_ids {
        let mut list_2482 = scope_2479.start_list(true, Some("item"));
        for item_2481 in var_2480 {
            #[allow(unused_mut)]
            let mut entry_2483 = list_2482.entry();
            entry_2483.string(item_2481);
        }
        list_2482.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2484 = writer.prefix("LaunchTemplateName");
    if let Some(var_2485) = &input.launch_template_names {
        let mut list_2487 = scope_2484.start_list(true, Some("item"));
        for item_2486 in var_2485 {
            #[allow(unused_mut)]
            let mut entry_2488 = list_2487.entry();
            entry_2488.string(item_2486);
        }
        list_2487.finish();
    }
    #[allow(unused_mut)]
    let mut scope_2489 = writer.prefix("Filter");
    if let Some(var_2490) =


Condition::Then),
                Some(ITCondition::Then),
                Some(ITCondition::Then),
            ),
            0b1001 => (
                Some(ITCondition::Else),
                Some(ITCondition::Then),
                Some(ITCondition::Then),
            ),
            0b0101 => (
                Some(ITCondition::Then),
                Some(ITCondition::Else),
                Some(ITCondition::Then),
            ),
            0b1101 => (
                Some(ITCondition::Else),
                Some(ITCondition::Else),
                Some(ITCondition::Then),
            ),
            0b0011 => (
                Some(ITCondition::Then),
                Some(ITCondition::Then),
                Some(ITCondition::Else),
            ),
            0b1011 => (
                Some(ITCondition::Else),
                Some(ITCondition::Then),
                Some(ITCondition::Else),
            ),
            0b0111 => (
                Some(ITCondition::Then),
                Some(ITCondition::Else),
                Some(ITCondition::Else),
            ),
            0b1111 => (
                Some(ITCondition::Else),
                Some(ITCondition::Else),
                Some(ITCondition::Else),
            ),
            _ => (None, None, None),
        }
    };

    Instruction::IT {
        x,
        y,
        z,
        firstcond: Condition::from_u16(firstcond).unwrap_or(Condition::AL),
        mask,
    }
}
<gh_stars>0
#[doc = "Reader of register CTRL1"]
pub type R = crate::R<u16, super::CTRL1>;
#[doc = "Writer for register CTRL1"]
pub type W = crate::W<u16, super::CTRL1>;
#[doc = "Register CTRL1 `reset()`'s with value 0"]
impl crate::ResetValue for super::CTRL1 {
    type Type = u16;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0
    }
}
#[doc = "DMA Enable for XBAR_OUT2\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DEN2_A {
    #[doc = "0: DMA disabled"]
    DEN2_0 = 0,
    #[doc = "1: DMA enabled"]
    DEN2_1 = 1,
}
impl From<DEN2_A> for bool {
    #[inline(always)]
    fn from(variant: DEN2_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `DEN2`"]
pub type DEN2_R = crate::R<bool, DEN2_A>;
impl DEN2_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> DEN2_A {
        match self.bits {
            false => DEN2_A::DEN2_0,
            true => DEN2_A::DEN2_1,
        }
    }
    #[doc = "Checks if the value of the field is `DEN2_0`"]
    #[inline(always)]
    pub fn is_den2_0(&self) -> bool {
        *self == DEN2_A::DEN2_0
    }
    #[doc = "Checks if the value of the field is `DEN2_1`"]
    #[inline(always)]
    pub fn is_den2_1(&self) -> bool {
        *self ==


d_for_version(&repo, &name, &version_a.to_string())?
            .ok_or_else(|| HeadCommitNotFoundError {
                crate_name: name.to_string(),
                version: version_a.clone(),
            })?;
        let tree_a = repo.find_commit(commit_oid_a)?.tree()?;
        let tree_a = self.get_subdirectory_tree(&repo, &tree_a, &toml_path)?;

        let commit_oid_b = self
            .get_head_commit_oid_for_version(&repo, &name, &version_b.to_string())?
            .ok_or_else(|| HeadCommitNotFoundError {
                crate_name: name.to_string(),
                version: version_b.clone(),
            })?;
        let tree_b = repo.find_commit(commit_oid_b)?.tree()?;
        let tree_b = self.get_subdirectory_tree(&repo, &tree_b, &toml_path)?;

        let diff =
            repo.diff_tree_to_tree(Some(&tree_a), Some(&tree_b), Some(&mut DiffOptions::new()))?;

        Ok(VersionDiffInfo {
            repo,
            commit_a: commit_oid_a,
            commit_b: commit_oid_b,
            diff,
        })
    }

    // This method takes two local repositories as input,
    //     Presumably two different versions of the same code base initiated in different repos
    //     For example, when comparing code for two versions of a crate hosted on crates.io;
    // and returns VersionDiffInfo between the heads of the two repositories
    pub(crate) fn get_version_diff_info_between_repos<'a>(
        &'a self,
        repo_version_a: &'a Repository,
        repo_version_b: &Repository,
    ) -> Result<VersionDiffInfo<'a>> {
        let version_a_commit = repo_version_a.head()?.peel_to_commit()?;
        let version_a_tree = version_a_commit.tree()?;

        // make repo_b a branch of repo_a
        let head_b = repo_version_b.head()?.peel_to_commit()?;
        self.setup_remote(
            &repo_version_a,
            &repo_version_b
                .path()
                .to_str()
                .ok_or_else(|| anyhow!("no local path found for repository"))?
                .to_string(),
            &head_b.id().to_string(),
        )?;

        // Get head commit for repo_b branch on repo_a
        let version_b_commit = repo_version_a.find_commit(head_b.id())?;
        let version_b_tree = version_b_commit.tree()?;

        let diff = repo_version_a.diff_tree_to_tree(
            Some(&version_a_tree),
            Some(&version_b_tree),
            Some(&mut DiffOptions::new()),
        )?;

        Ok(VersionDiffInfo {
            repo: &repo_version_a,
            commit_a: version_a_commit.id(),
            commit_b: version_b_commit.id(),
            diff,
        })
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use guppy::{graph::PackageGraph, MetadataCommand};
    use serial_test::serial;

    fn get_test_diff_analyzer() -> DiffAnalyzer {
        DiffAnalyzer::new().unwrap()
    }

    fn get_test_graph() -> PackageGraph {
        MetadataCommand::new()
            .current_dir(PathBuf::from("resources/test/valid_dep"))
            .build_graph()
            .unwrap()
    }

    #[test]
    fn test_diff_trim_git_url() {
        let url = "https://github.com/facebookincubator/cargo-guppy/tree/main/guppy";
        let trimmed_url = trim_remote_url(url).unwrap();
        assert_eq!(
            trimmed_url,
            "https://github.com/facebookincubator/


tag: String?, model:User?): Unit {
        tag?.let { t ->
            println()
            println(t.toUpperCase())
        }

        model?.let { m ->
            println("User: " + m.id + ", " + m.firstName + ", " + m.lastName)
        }
    }
    /*
//<doc:output>
```bat
    2
    User: 2, jane, doe-02

    ALL
    User: 1, john, doe-01
    User: 3, john, doe-03
    User: 4, jane, doe-04
    User: 2, user_two, doe-02

    RECENT
    User: 4, jane, doe-04
    User: 3, john, doe-03

    OLDEST
    User: 1, john, doe-01
    User: 2, user_two, doe-02

    FIRST
    User: 1, john, doe-01

    LAST
    User: 4, jane, doe-04
    3
```
//</doc:output>
*/
}
/**
<slate_header>
  author: Kishore Reddy
  url: www.github.com/code-helix/slatekit
  copyright: 2015 Kishore Reddy
  license: www.github.com/code-helix/slatekit/blob/master/LICENSE.md
  desc: A tool-kit, utility library and server-backend
  usage: Please refer to license on github for more info.
</slate_header>
  */

package slatekit.examples

//<doc:import_required>
import slatekit.common.writer.*

//</doc:import_required>

//<doc:import_examples>

import slatekit.common.DateTime

import slatekit.results.Try
import slatekit.results.Success
//</doc:import_examples>

class Example_Console : Command("console") {

  override fun execute(request: CommandRequest) : Try<Any>
  {
    //<doc:examples>
    // ConsoleWriter with semantic ( title, url, error, success, highlight ) writing.
    val writer = ConsoleWriter()

    // Case 1: Title - prints text in title format ( CAPS + Color Cyan )
    writer.title("title is in CAPS")

    // Case 2: Subtitle ( Color Cyan )
    writer.subTitle("subtitle is in color cyan")

    // Case 3: Url ( Color blue )
    writer.url("url is in blue")

    // Case 4: Highlight ( Color Yellow )
    writer.highlight("highlight is in color")

    // Case 5: Subtitle ( Color Red )
    writer.important("important is red")

    // Case 6: Subtitle ( Color Red )
    writer.failure("error shown in red")

    // Case 7: Subtitle ( Color Green )
    writer.success("success is in green")

    // Case 8: Subtitle ( Color Green )
    writer.text("normal text")

    // Case 9: Tab
    writer.tab()

    // Case 10: New line
    writer.line()

    // Case 11: Label "Key :"
    writer.label("Key")

    // Case 12: Key/Value = "Name : Superman"
    writer.keyValue("Name", "Superman")
    writer.lines(2)

    // Case 13: List of items ( unordered and ordered )
    writer.list( listOf( 1, true , "www.slatekit.com", DateTime.now(), 12.34 ), true)
    writer.list( listOf( 2, false, "www.codehelix.co", DateTime.now(), 56.78 ), true)

    // Case 14: Supply a list of items to print specifying the semantic mode ( title, url, etc )
    writer.writeItems(listOf(
      TextOutput(TextType.Title     , "About App"                   , true),
      TextOutput(TextType.Subtitle  , "Example of Console component", true),
      TextOutput(TextType.Url       , "http://www.slatekit.com"     , true),
      TextOutput(TextType.Highlight , "visit us for more info"      , true)
    ))
    //</doc:examples>
    return Success("")
  }

  /*
  //<doc:output>
{{< highlight kotlin >}}
  TITLE IS IN CAPS
  subtitle is in color cyan
  url is in blue
  highlight is in color
  important is red
  error shown in red
  success is in green

  Key
  Name =  Superman

  ABOUT APP
  Example of Console component
  http://www.slatekit.


cator(
            strokeWidth = 2.dp,
            modifier = Modifier.size(24.dp)
        )
    }

    AnimatedVisibility(
        visible = !progress,
        enter = fadeIn() + scaleIn(),
        exit = scaleOut() + fadeOut()
    ) {
        Icon(
            painter = painterResource(id = R.drawable.chevron_right),
            contentDescription = null,
            modifier = Modifier
                .rotate(animateDegrees)
        )
    }
}

@Composable
private fun ArtifactList(
    artifacts: List<Artifact>,
    download: (Context, Artifact) -> Unit
) = Column(
    modifier = Modifier
        .padding(all = 10.dp)
        .clip(shape = MaterialTheme.shapes.medium)
        .border(
            border = CardDefaults.outlinedCardBorder(),
            shape = MaterialTheme.shapes.medium
        )
) {
    val context = LocalContext.current

    artifacts.forEachIndexed { index, artifact ->
        val jobState by ArtifactJob.getJobState(artifact.id).collectAsStateWithLifecycle(
            initialValue = ArtifactJob.JobState.Empty
        )

        ArtifactItem(
            artifact = artifact,
            onClick = { download(context, artifact) },
            trailing = {
                ArtifactTrailing(
                    jobState = jobState
                )
            }
        )

        if (index < artifacts.size - 1) {
            HorizontalDivider()
        }
    }
}

@Composable
private fun ArtifactTrailing(
    jobState: ArtifactJob.JobState
) = Box(
    contentAlignment = Alignment.Center
) {
    val animatedScale by animateFloatAsState(
        targetValue = if (jobState.isStarting) 0.65f else 1f,
        animationSpec = spring(stiffness = Spring.StiffnessMediumLow)
    )

    when (jobState) {
        is ArtifactJob.JobState.Pending -> CircularProgressIndicator(
            strokeWidth = 2.dp,
            modifier = Modifier.size(24.dp)
        )

        is ArtifactJob.JobState.Running -> CircularProgressIndicator(
            strokeWidth = 2.dp,
            progress = { jobState.progress },
            modifier = Modifier.size(24.dp)
        )

        else -> Unit
    }

    Icon(
        painter = painterResource(
            id = if (jobState.isStarting) R.drawable.file_type_zip else R.drawable.download
        ),
        contentDescription = null,
        modifier = Modifier.scale(animatedScale)
    )
}

private val ArtifactJob.JobState.isStarting
    inline get() = this is ArtifactJob.JobState.Pending || this is ArtifactJob.JobState.Runningpackage dev.sanmer.github.artifacts.database.dao

import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.Query
import androidx.room.Transaction
import androidx.room.Update
import dev.sanmer.github.artifacts.database.entity.RepoEntity
import dev.sanmer.github.artifacts.database.entity.RepoWithToken
import kotlinx.coroutines.flow.Flow

@Dao
interface RepoDao {
    @Query("SELECT * FROM repo ORDER BY updatedAt DESC")
    fun getAllAsFlow(): Flow<List<RepoEntity>>

    @Query("SELECT * FROM repo ORDER BY updatedAt DESC")
    suspend fun getAll(): List<RepoEntity>

    @Transaction
    @Query("SELECT * FROM repo ORDER BY updatedAt DESC")
    fun getAllWithTokenAsFlow(): Flow<List<RepoWithToken>>

    @Query("SELECT * FROM repo WHERE id = :id")
    fun getAsFlow(id: Long): Flow<RepoEntity?>

    @Insert
    suspend fun insert(value: RepoEntity)

    @Update
    suspend fun update(value: RepoEntity)

    @Update
    susp


x7bcb9557,0x645d1558,0x68e89559,0x870780d7}},	//   _regu, _imsi, hudd, تبال,
   {{0x4426955a,0x4439120b,0x68e8955b,0x2cac955c}},	//   _ano_, _hos_, kudd, _budd_,
   {{0x4439155d,0x7bcb955e,0x7643955f,0x6aa38d02}},	//   _kos_, _pegu, rkny, _rinf,
   {{0x44391560,0x387f885c,0x7643808e,0x44268706}},	//   _jos_, _ukur_, skny, _cno_,
   {{0x44391561,0x9f4f8e1b,0xab659562,0x27ff8122}},	//   _mos_, regó_, явил, _ibun_,
   {{0x44391563,0x44269564,0x7e55803f,0x68e88c2e}},	//   _los_, _eno_, _عناص, fudd,
   {{0x2cac9565,0x7bcb9566,0x3ead9567,0x69c19568}},	//   _gudd_, _tegu, _huet_, rble,
   {{0x44d7802e,0xe8df001c,0xbbaa1370,0x69c18192}},	//   mă_, _chứa_, _कलेक, sble,
   {{0x7d1e09cf,0x644b9569,0x44d7802e,0x2fcd81c0}},	//   _srps, _ilgi, lă_, _meeg_,
   {{0x2fcd956a,0x4439156b,0x68e8956c,0x629d801b}},	//   _leeg_, _aos_, budd, ůsob,
   {{0x44d78012,0x7ae9956d,0x44268114,0x78a4156e}},	//   nă_, luet, _yno_, _tiiv,
   {{0x4426040e,0x2fcd90af,0x4439156f,0x5baa1570}},	//   ño_, _neeg_, _cos_, скам_,
   {{0x44391571,0x78bb003b,0xe9da11b1,0x64440079}},	// [a60] _dos_, _čuva, йка_, rkii,
   {{0xa7fb04c3,0x64441572,0x7c399106,0x27ff8041}},	//   miña, skii, _lowr, _abun_,
   {{0xe821035a,0xe8fa12e1,0x7af61573,0xa3e50f12}},	//   याचा_, сле_, styt, _नाच_,
   {{0xa3ea800c,0x1bea809a,0x44391574,0xafdb0257}},	//   _टाइप_, _टाइल_, _gos_, lhør,
   {{0x9cf880ab,0x7bc41575,0x2fcd9576,0xdfcf80a0}},	//   _আছেন_, mbiu, _deeg_, ايه_,
   {{0x443901c5,0x644b8084,0x44268b81,0x412a1577}},	//   _zos_, _algi, _sno_, _лого_,
   {{0xe7ed035a,0x44390282,0x44d78087,0x69dc00e8}},	//   _झाला_, _yos_, gă_, _idre,
   {{0xb60


h2 id="deep-cox-mixtures">Deep Cox Mixtures

The Cox Mixture involves the assumption that the survival function
of the individual to be a mixture of K Cox Models. Conditioned on each
subgroup  Z=k ; the PH assumptions are assumed to hold and the baseline
hazard rates is determined non-parametrically using an spline-interpolated
Breslow's estimator.

For full details on Deep Cox Mixture, refer to the paper [1].

References

[1] Deep Cox Mixtures
for Survival Regression. Machine Learning in Health Conference (2021)

  @article{nagpal2021dcm,
  title={Deep Cox mixtures for survival regression},
  author={Nagpal, Chirag and Yadlowsky, Steve and Rostamzadeh, Negar and Heller, Katherine},
  journal={arXiv preprint arXiv:2101.06536},
  year={2021}
  }

auton_survival.models.dsm

Deep Survival Machines

Deep Survival Machines (DSM) is a fully parametric approach to model
Time-to-Event outcomes in the presence of Censoring first introduced in
[1].
In the context of Healthcare ML and Biostatistics, this is known as 'Survival
Analysis'. The key idea behind Deep Survival Machines is to model the
underlying event outcome distribution as a mixure of some fixed  k
parametric distributions. The parameters of these mixture distributions as
well as the mixing weights are modelled using Neural Networks.

Example Usage

>>> from dsm import DeepSurvivalMachines
>>> from dsm import datasets
>>> # load the SUPPORT dataset.
>>> x, t, e = datasets.load_dataset('SUPPORT')
>>> # instantiate a DeepSurvivalMachines model.
>>> model = DeepSurvivalMachines()
>>> # fit the model to the dataset.
>>> model.fit(x, t, e)
>>> # estimate the predicted risks at the time
>>> model.predict_risk(x, 10)

Deep Recurrent Survival Machines

Deep Recurrent Survival Machines (DRSM) builds on the original DSM
model and allows for learning of representations of the input covariates using
Recurrent Neural Networks like LSTMs, GRUs. Deep Recurrent Survival
Machines is a natural fit to model problems where there are time dependendent
covariates. Examples include situations where we are working with streaming
data like vital signs, degradati


       MULTI_FIND_CONDITION_NE_COLUMN,
            MULTI_FIND_CONDITION_NE_VALUE,
        )?
        .find_all()?;

    println!("Search Rows completed in {:.2?}", start.elapsed());

    println!(
        "-- FIRST ROW Where Value for {:?} = {:?} --",
        SINGLE_FIND_CONDITION_EQ_COLUMN, SINGLE_FIND_CONDITION_EQ_VALUE
    );
    println!("{}", to_string_pretty(&row)?);
    println!();

    println!(
        "-- ALL ROWS (Count: {}) Where Value for {:?} != {:?} --",
        rows.len(),
        MULTI_FIND_CONDITION_NE_COLUMN,
        MULTI_FIND_CONDITION_NE_VALUE
    );
    println!("{}", to_string_pretty(&rows)?);

    Ok(())
}
mod sealed {
    use super::*;

    pub
    trait RepresentsAutoTraits {}

    impl RepresentsAutoTraits for dyn Send + 'static {}
    impl RepresentsAutoTraits for dyn Sync + 'static {}
    impl RepresentsAutoTraits for dyn Send + Sync + 'static {}
    impl RepresentsAutoTraits for NoAutoTraits {}
}

pub
struct NoAutoTraits (
    PhantomNotSendNorSync,
    ::core::convert::Infallible,
);

type PhantomNotSendNorSync =
    ::core::marker::PhantomData<*mut ()>
;

// struct PhantomNotSend(PhantomNotSendNorSync);
// unsafe // Safety: no API whatsoever.
//     impl Sync for PhantomNotSend {}

// type PhantomNotSync =
//     ::core::marker::PhantomData<&'static ::core::cell::Cell<u8>>
// ;

/// This is a "fake type-level `enum`" to hint at the generated documentation
/// what the purpose of some type params is.
///
/// ```rust
/// # macro_rules! ignore {($($t:tt)*) => ()} ignore! {
/// #[type_level_enum]
/// pub enum Sendness {
///     /// `+ ?Send` (default)
///     MaybeNotSend,
///     /// `+ Send
///     dyn Send,
/// }
/// # } fn main () {}
/// ```
#[doc(hidden)] #[allow(nonstandard_style)]
pub
mod Sendness {
    use super::*;

    pub
    trait T : sealed::RepresentsAutoTraits {}

    impl T for dyn Send {}
    impl T for dyn Sync {}
    impl T for dyn Send + Sync {}
    impl T for NoAutoTraits {}
}

/// This is a "fake type-level `enum`" to hint at the generated documentation
/// what the purpose of some type params is.
///
/// ```rust
/// # macro_rules! ignore {($($t:tt)*) => ()} ignore! {
/// #[type_level_enum]
/// pub enum Syncness {
///     /// `+ ?Sync` (default)
///     MaybeNotSync,
///     /// `+ Sync
///     dyn Sync,
/// }
/// # } fn main () {}
/// ```
#[doc(hidden)] #[allow(nonstandard_style)]
pub
mod Syncness {
    use super::*;

    pub
    trait T : sealed::RepresentsAutoTraits {}

    impl T for dyn Send {}
    impl T for dyn Sync {}
    impl T for dyn Send + Sync {}
    impl T for NoAutoTraits {}
}
<reponame>gobuki/jlrs
//! Support for values with the `Core.MethodTable` type.
//!
//! The documentation for this module has been slightly adapted from the comments for this struct
//! in [`julia.h`]
//!
//! [`julia.h`]: https://github.com/JuliaLang/julia/blob/96786e22ccabfdafd073122abb1fb69cea921e17/src/julia.h#L535

use super::{array::Array, module::Module, symbol::Symbol, Value};
use crate::error::{JlrsError, JlrsResult};


margin-top:auto}#atomic .My\(a\),#atomic .Mb\(a\){margin-bottom:auto}.smartphone .smartphone_My\(10px\),#atomic .Mt\(10px\)\!,.smartphone .smartphone_Mt\(10px\){margin-top:10px!important}.smartphone .smartphone_My\(10px\),.smartphone .smartphone_Mb\(10px\){margin-bottom:10px!important}.fin-smart-banner .fin-smart-banner_Mt\(70px\){margin-top:70px!important}.grid-layout .grid-layout_Mt\(15px\),.smartphone .smartphone_Mt\(15px\){margin-top:15px!important}.HideBottomBar .HideBottomBar_Mt\(\$searchKeywordHideMargin\),.modal-open .modal-open_Mt\(\$searchKeywordHideMargin\){margin-top:-21px!important}.ie-7 .ie-7_Mt\(160px\){margin-top:160px!important}.ie-7 .ie-7_Mt\(2px\){margin-top:2px!important}#atomic .Mt\(\$company360OverlayTopMargin\){margin-top:calc((100vh - 850px)/2)}#atomic .Mt\(-10px\){margin-top:-10px}#atomic .Mt\(-12px\){margin-top:-12px}#atomic .Mt\(-13px\){margin-top:-13px}#atomic .Mt\(-145px\){margin-top:-145px}#atomic .Mt\(-14px\){margin-top:-14px}#atomic .Mt\(-15px\),#atomic .Mt\(plButtonMg\){margin-top:-15px}#atomic .Mt\(-17px\){margin-top:-17px}#atomic .Mt\(-18px\){margin-top:-18px}#atomic .Mt\(-1px\){margin-top:-1px}#atomic .Mt\(-2\.5px\){margin-top:-2.5px}#atomic .Mt\(-20px\){margin-top:-20px}#atomic .Mt\(-20px\)\!{margin-top:-20px!important}#atomic .Mt\(-23px\){margin-top:-23px}#atomic .Mt\(-25px\){margin-top:-25px}#atomic .Mt\(-2px\){margin-top:-2px}#atomic .Mt\(-30px\){margin-top:-30px}#atomic .Mt\(-32px\){margin-top:-32px}#atomic .Mt\(-35px\){margin-top:-35px}#atomic .Mt\(-3px\){margin-top:-3px}#atomic .Mt\(-40px\){margin-top:-40px}#atomic .Mt\(-48px\){margin-top:-48px}#atomic .Mt\(-4px\){margin-top:-4px}#atomic .Mt\(-50px\){margin-top:-50px}#atomic .Mt\(-5px\){margin-top:-5px}#atomic .Mt\(-60px\){margin-top:-60px}#atomic .Mt\(-6px\){margin-top:-6px}#atomic .Mt\(-75px\){margin-top:-75px}#atomic .Mt\(-78px\){margin-top:-78px}#atomic .Mt\(-7px\){margin-top:-7px}#atomic .Mt\(-8px\){margin-top:-8px}#atomic .Mt\(-90px\){margin-top:-90px}#atomic .Mt\(0\.25rem\){margin-top:.25rem}#atomic .Mt\(0\.5rem\){margin-top:.5rem}#atomic .Mt\(10\%\){margin-top:10%}#atomic .Mt\(107px\){margin-top:107px}#atomic .Mt\(117px\){margin-top:117px}#atomic .Mt\(120px\){margin-top:120px}#atomic .Mt\(14px\)\!{margin-top:14px!important}


t_and_clear_direction_flag
.private_extern _abi_test_get_and_clear_direction_flag
_abi_test_get_and_clear_direction_flag:
_CET_ENDBR
	pushfq
	popq	%rax
	andq	$0x400,%rax
	shrq	$10,%rax
	cld
	.byte	0xf3,0xc3

.globl	_abi_test_set_direction_flag
.private_extern _abi_test_set_direction_flag
_abi_test_set_direction_flag:
_CET_ENDBR
	std
	.byte	0xf3,0xc3

#endif