case "Exec":
                var words = CommandWords(Convert.ToString(arguments[0]) ?? "");
                if (words.Length == 0) return false;
                int offset = words[0].Equals("exec", StringComparison.OrdinalIgnoreCase) || words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
                if (words.Length > offset && Exists(words[offset]))
                { Start(words[offset], words.Skip(offset + 1).ToArray()); return true; }
                if (words.Length > offset && events is ICSharpScriptHost scriptHost
                    && (offset == 1 || scriptHost.HasCSharpScript(words[offset])))
                {
                    string command = Convert.ToString(arguments[0]) ?? "";
                    if (words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase)) command = "exec" + command.TrimStart()[5..];
                    scriptHost.ExecuteCSharpScript(command); return true;
                }
                return false;

case "SetEventProc":
                SetStateEvent([arguments[0], !string.IsNullOrWhiteSpace(Convert.ToString(arguments[1])), true, arguments[1]]);
                return true;

public bool Cancel(string name)
    {
        Verify();
        Invocation[] calls;
        lock (sync) calls = active.Where(call => call.Name.Equals((name ?? "").Trim(), StringComparison.OrdinalIgnoreCase)).ToArray();
        foreach (var call in calls)
            try { call.Cancellation.Cancel(); } catch (ObjectDisposedException) { }
        return calls.Length != 0;
    }

private void SetStateEvent(object?[] arguments)
    {
        string name = EventName(arguments[0]);
        if (name.Length == 0) return;
        RemoveState(name);
        if (!Flag(arguments[1])) return;
        string? sourceName = name.ToLowerInvariant() switch
        {
            "changehitpoints" => "UO.HitPointsChanged", "changemana" => "UO.ManaChanged", "changestamina" => "UO.StaminaChanged",
            "death" or "seenewplayer" => null,
            _ => ""
        };
        if (sourceName == "")
        {
            native("Print", [$"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina."]);
            return;
        }
        bool repeat = true;
        string handler = "";
        if (arguments.Length == 3)
        {
            string text = Convert.ToString(arguments[2]) ?? "";
            if (text.Length != 0 && !NumberConversions.TryStr2Int(text, out _) && arguments[2] is not bool)
                handler = HandlerName(arguments[2]);
            else repeat = Flag(arguments[2]);
        }
        if (arguments.Length == 4) { repeat = Flag(arguments[2]); handler = HandlerName(arguments[3]); }
        var state = new StateEvent(name, repeat, handler);
        if (events is null || sourceName is null)
        {
            if (name.Equals("SeeNewPlayer", StringComparison.OrdinalIgnoreCase)) state.Mobiles = ReadMobiles();
            else state.Last = ReadState(name);
        }
        lock (sync)
        {
            Verify();
            if (events is not null && sourceName is not null)
                state.Subscription = Subscribe(sourceName, _ => { Trigger(state); return Task.CompletedTask; });
            stateEvents[name] = state;
        }
    }

internal static bool BelongsTo(BackNewbieItemRule rule, string listId) => rule != null
            && string.Equals(string.IsNullOrEmpty(rule.ListId) ? DefaultId : rule.ListId,
                listId, StringComparison.Ordinal);

public static void RequestMobileStatus(World world, uint serial, bool force = false)
        {
            if (world.InGame)
            {
                Entity ent = world.Get(serial);

                if (ent != null)
                {
                    if (force)
                    {
                        if (ent.HitsRequest >= HitsRequestStatus.Pending)
                        {
                            SendCloseStatus(world, serial);
                        }
                    }

                    if (ent.HitsRequest < HitsRequestStatus.Received)
                    {
                        ent.HitsRequest = HitsRequestStatus.Pending;
                        force = true;
                    }
                }

                if (force && SerialHelper.IsValid(serial))
                {
                    //ent = ent ?? World.Player;
                    //ent.AddMessage(MessageType.Regular, $"PACKET SENT: 0x{serial:X8}", 3, 0x34, true, TextType.OBJECT);
                    Socket.Send_StatusRequest(serial);
                }
            }
        }

public static void UsePrimaryAbility(World world)
        {
            if (world?.Player == null)
                return;

            ref var ability = ref world.Player.Abilities[0];

            if (((byte) ability & 0x80) == 0)
            {
                for (int i = 0; i < 2; i++)
                {
                    world.Player.Abilities[i] &= (Ability) 0x7F;
                }

                SendAbility(world, (byte)ability, true);
            }
            else
            {
                SendAbility(world, 0, true);
            }

            ability ^= (Ability) 0x80;
        }

public int CheckLosCell(int x, int y, int z, int map, int options) => Invoke(() =>

        {

            if (_world.Map == null || map != _world.MapIndex)

                return 0;



            int algorithm = options & 0xFF;

            if (algorithm < 1 || algorithm > 4)

                algorithm = 3;

            bool useNoShoot = algorithm == 3 || (algorithm == 4 && (options & 0x200) != 0);

            bool allowWindow = algorithm == 4 && (options & 0x400) != 0;



            bool Blocks(StaticTiles data, int tileZ)

            {

                int height = Math.Max(1, (int)data.Height);

                bool overlapsRay = z >= tileZ - 2 && z <= tileZ + height + 2;

                if (!overlapsRay)

                    return false;

                if (data.IsWindow && allowWindow)

                    return false;

                return data.IsWall || data.IsImpassable || useNoShoot && data.IsNoShoot;

            }



            for (GameObject tile = _world.Map.GetTile(x, y); tile != null; tile = tile.TNext)

            {

                if (tile is Land land)

                {

                    if (land.TileData.IsImpassable && Math.Abs(z - land.Z) <= 20)

                        return 0;

                    continue;

                }



                if (tile is Static staticTile && Blocks(staticTile.ItemData, staticTile.Z))

                    return 0;

                if (tile is Multi multi && Blocks(multi.ItemData, multi.Z))

                    return 0;

                if (tile is Item item && Blocks(item.ItemData, item.Z))

                    return 0;

            }



            return 1;

        });

bool Blocks(StaticTiles data, int tileZ)

            {

                int height = Math.Max(1, (int)data.Height);

                bool overlapsRay = z >= tileZ - 2 && z <= tileZ + height + 2;

                if (!overlapsRay)

                    return false;

                if (data.IsWindow && allowWindow)

                    return false;

                return data.IsWall || data.IsImpassable || useNoShoot && data.IsNoShoot;

            }

public void ClearUserStatics() => Invoke(_manager.ClearUserStatics);

public void ClientHide(int serial) => Invoke(() =>

        {

            Entity entity = _world.Get(unchecked((uint)serial)) as Entity;

            if (entity == null || entity.IsDestroyed)

            {

                Error($"UO.ClientHide: object 0x{unchecked((uint)serial):X8} is not loaded.");

                return;

            }

            if (entity.Serial == _world.Player?.Serial)

            {

                Error("UO.ClientHide: refusing to hide the player locally.");

                return;

            }

            HideLocally(entity);

        });

public void DisconnectClient() => Invoke(() =>

        {

            // With AR enabled, let the automatic disconnect pause resume on

            // login. With AR disabled, this worker must reach its own Connect.

            if (!(_world.SessionControl?.AutoReconnect ?? Settings.GlobalSettings.Reconnect))

                _manager.BeginScriptControlledDisconnect(_scriptKey);

            if (_world.SessionControl is { } session)

            {

                session.RequestDisconnect();

                _manager.PrepareForReconnect();

                return;

            }

            LoginScene loginScene = Client.Game.GetScene<LoginScene>();



            // Disconnect also cancels any active or in-flight transport.

            NetClient.Socket.Disconnect();

            _manager.PrepareForReconnect();



            // Socket.Disconnect detaches its callback, so it does not trigger

            // GameScene's normal connection-loss handler. Schedule the same

            // preserving transition explicitly when automatic reconnect is on.

            // With AR off, keep the worker alive for a later UO.Connect call.

            if (Settings.GlobalSettings.Reconnect)

                Client.Game?.GetScene<GameScene>()?.RequestReconnectPreservingYoko();

            if (loginScene != null)

            {

                loginScene.Reconnect = Settings.GlobalSettings.Reconnect;

                loginScene.PopupMessage = null;

                loginScene.CurrentLoginStep = LoginSteps.Main;

            }

        });

public int Dismount() => Invoke(() =>

        {

            _manager.MountRequests.Request(

                _world, 0, mount: false,

                serial => NetClient.Socket.Send_UseObjectRequest(serial), Environment.TickCount64);

            return MountedLayerSerialUnsafe();

        });

public int EmptyContainer(int sourceContainerId, int targetContainerId, int delayMs)

        {

            if (sourceContainerId == 0 || targetContainerId == 0 || sourceContainerId == targetContainerId)

                return 0;

            bool ready = Invoke(() => _world.Items.Get((uint)sourceContainerId) is Item source

                && source.ContainerContentsReceived);

            if (!ready)

            {

                bool requested = Invoke(() =>

                {

                    Item source = _world.Items.Get((uint)sourceContainerId);

                    if (source == null || source.IsDestroyed || _world.Get((uint)targetContainerId) == null

                        || (!source.IsCorpse && !source.ItemData.IsContainer)) return false;

                    GameActions.DoubleClick(_world, source.Serial);

                    return true;

                });

                if (!requested) return 0;

                var elapsed = Stopwatch.StartNew();

                while (elapsed.ElapsedMilliseconds < 3000)

                {

                    Wait(25);

                    if (Invoke(() => _world.Items.Get((uint)sourceContainerId) is Item source

                        && source.ContainerContentsReceived))

                    { ready = true; break; }

                }

                if (!ready)

                {

                    Error("UO.EmptyContainer: no complete container contents arrived within 3000 ms.");

                    return 0;

                }

            }

            var result = MoveContainerItems(sourceContainerId, -1, -1, targetContainerId, -1, -1, 0, delayMs, false);

            return result.Selected > 0 && result.Sent == result.Selected ? 1 : 0;

        }

public void EquipLastWeapon()

        {

            if (_lastRightHand != 0) Equip((int)Layer.OneHanded, _lastRightHand);

            if (_lastLeftHand != 0) Equip((int)Layer.TwoHanded, _lastLeftHand);

        }

bool MatchesZ(Entity entity)

                {

                    if (player == null || effectiveMaxZ < 0)

                        return true;

                    Entity zEntity = entity;

                    if (entity is Item && containerId > 1)

                        zEntity = _world.Get(unchecked((uint)containerId)) ?? entity;

                    return Math.Abs(zEntity.Z - player.Z) <= effectiveMaxZ;

                }

private static string FormatTileInfo(GameObject tile, int map)

        {

            string details = $"ObjectType={tile.GetType().Name}\n"

                + $"Graphic/Tile=0x{tile.Graphic:X4} ({tile.Graphic})\n"

                + $"Hue/Colour=0x{tile.Hue:X4} ({tile.Hue})\n"

                + $"X={tile.X} Y={tile.Y} Z={tile.Z} Map={map}\n"

                + $"PriorityZ={tile.PriorityZ}\n"

                + $"Distance={tile.Distance}\n"

                + $"AllowedToDraw={tile.AllowedToDraw}\n"

                + $"AlphaHue={tile.AlphaHue}";

            string report = tile switch

            {

                Land land => details

                    + $"\nName={land.TileData.Name ?? string.Empty}"

                    + $"\nFlags={land.TileData.Flags}"

                    + $"\nIsFlat={!land.IsStretched}"

                    + $"\nNormalLeft={land.NormalLeft}"

                    + $"\nNormalRight={land.NormalRight}"

                    + $"\nNormalTop={land.NormalTop}"

                    + $"\nNormalBottom={land.NormalBottom}"

                    + $"\nMinZ={land.MinZ}"

                    + $"\nAverageZ={land.AverageZ}"

                    + $"\nYOffsets={land.YOffsets}",

                Static staticTile => details

                    + $"\nName={staticTile.ItemData.Name ?? string.Empty}"

                    + $"\nFlags={staticTile.ItemData.Flags}"

                    + $"\nHeight={staticTile.ItemData.Height}"

                    + $"\nIsVegetation={staticTile.IsVegetation}",

                Multi multi => details

                    + $"\nState={multi.State}"

                    + $"\nIsMovable={multi.IsMovable}",

                _ => details

            };

            report += "\n" + FormatAvailableScalars("Tile", tile);

            if (tile is Land loadedLand) report += FormatAvailableScalars("TileData", loadedLand.TileData);

            else if (tile is Static loadedStatic) report += FormatAvailableScalars("TileData", loadedStatic.ItemData);

            return report;

        }

public string GetAltName(int id) => GetTitle(id);

public int GetAutoBuyDelay() => Invoke(() => ProfileManager.CurrentProfile?.BackNewbieAutoBuyDelay ?? 3);

public int[] GetContent(int containerId) => Invoke(() => _world.Items.Values

            .Where(item => !item.IsDestroyed && (containerId == 0 ? item.OnGround : item.Container == (uint)containerId))

            .Select(item => (int)item.Serial).ToArray());

private static string GetControlText(Control control)

        {

            return control switch

            {

                SessionGumpControl logical => logical.Text,

                Label label => label.Text,

                HtmlControl html => html.Text,

                StbTextBox textBox => textBox.Text,

                Checkbox checkbox => checkbox.Text,

                _ => null

            };

        }

public int GetGraphics(int id) => WithEntity(id, e => e.Graphic);

public int GetNotoriety(int id) => Invoke(() => (_world.Get(unchecked((uint)id)) as Mobile) is Mobile m ? (int)m.NotorietyFlag : 0);

public int[] GetQuestArrow() => Invoke(() => _world.CharacterPanels.QuestArrow());

public int[] GetWorldItems() => Invoke(() => _world.Items.Values

            .Where(item => !item.IsDestroyed && item.OnGround)

            .Select(item => (int)item.Serial).ToArray());

public int GetZ(int id) => WithEntity(id, e => e.Z);

private static string NormalizeAbilityName(string value) => string.Concat(

            (value ?? string.Empty).Where(char.IsLetterOrDigit)).ToUpperInvariant();

private void OpenInteractiveInfoGump(string title, string text)

        {

            // The invocation origin determines presentation. Renderer presence

            // alone must never make ordinary script queries open windows.

            if (_interactiveCommands)

                _infoGumpOpener(_world, title, text);

        }

public void PartyAcceptInvite() => Invoke(() =>

        {

            if (_world.Party.Inviter == 0) return;

            GameActions.RequestPartyAccept(_world.Party.Inviter);

            _world.Party.Leader = _world.Party.Inviter;

            _world.Party.Inviter = 0;

        });

private void RegisterFound(Mobile mobile)

        {

            _findCount++;

            _findFullQuantity++;

            RegisterFoundSerial(unchecked((int)mobile.Serial));

        }

public void RequestClientTarget(bool tileTarget)

        {

            int request = Interlocked.Increment(ref _clientTargetRequest);

            _clientTargetResponsePresent = false;

            _clientTargetResponse = Array.Empty<int>();

            Invoke(() =>

            {

                _clientTargetCancellation.Unregister();

                Action<GameObject> callback = target =>

                {

                    if (request != Volatile.Read(ref _clientTargetRequest))

                        return;

                    _clientTargetCancellation.Unregister();

                    if (target == null || (!tileTarget && !(target is Entity)))

                        _clientTargetResponse = Array.Empty<int>();

                    else

                    {

                        int serial = target is Entity entity ? (int)entity.Serial : 0;

                        _clientTargetResponse = new[] { serial, (int)target.Graphic, target.X, target.Y, target.Z };

                    }

                    _clientTargetResponsePresent = true;

                };

                _world.TargetManager.SetTargeting(callback, 0, TargetType.Neutral);

                // Cancellation may run on a worker thread. Queue ownership-checked

                // cleanup without waiting for the game thread or clearing a newer cursor.

                _clientTargetCancellation = _cancellationToken.Register(

                    () => _manager.ReleaseObjectSelection(callback));

            });

        }

public int ResolveSpell(string spellNameOrId) => ResolveClassicUOSpellId(spellNameOrId);

public void SetContextMenuHook(int id, int entry) => Invoke(() => _manager.SetContextMenuHook((uint)id, entry));

public int Snap(string name, int quality, bool includeUi)

            => Invoke(() => RequireGameView("Snap").TakeScreenshot(name, quality, includeUi));

public void StopAllScripts() => _manager.StopAll();

public bool SubExists(string subrutineName) => _manager.FindProcedureByName(subrutineName) != null;

public void TrackOff() => Invoke(() => _world.CharacterPanels.SetArrow(SessionCharacterPanels.TrackSerial, false, 0, 0));

public int TradeContainer(int windowIndex) => Invoke(() =>

        {

            ISessionTrade gump = FindTrade(windowIndex);

            return (int)(gump?.ID1 ?? 0);

        });

internal static IReadOnlyList<YokoProcedureInfo> DiscoverProcedures(string content, string filePath, string relativeFileName)

        {

            string originalScript = content ?? string.Empty;

            if (IsCompiledScriptFilePath(filePath)) return DiscoverCompiledProcedures(filePath, relativeFileName);

            if (IsSupportedScriptFilePath(filePath))

            {

                return DiscoverCSharpAutoloadProcedures(originalScript, filePath, relativeFileName);

            }

            return Array.Empty<YokoProcedureInfo>();

        }

internal void QueueTargetTile(ushort graphic, ushort x, ushort y, short z, CancellationToken owner = default)

        {

            lock (_pendingTargetLock)

            {

                owner.ThrowIfCancellationRequested();

                _pendingTargets.Enqueue(new PendingTarget(graphic, x, y, z, owner));

            }

        }

internal int TerminateProcedures(string selector)
        {
            selector = selector?.Trim() ?? string.Empty;
            bool all = selector.Equals("all", StringComparison.OrdinalIgnoreCase);
            if (all) _massMover?.Stop();
            if (all) _vendorPricer?.Stop();
            if (all) _follow?.RequestStop();
            YokoRunningScript[] selected;
// …
                if (all) _launchGeneration++;
                if (selector.Length == 0)
// …
                    if (all || (selector.Length != 0
// …
                if (run.TryStop())
// …
            if (all)
// …
            else if (selector.Length != 0) ClearGumpAutomation(selector);
            else foreach (var run in selected) ClearGumpAutomation(run.Key);
            SetStatus(stopped + cancelledPending == 0
                ? ClientLanguageManager.TranslateUi("No matching C# routines are running.")
                : string.Format(ClientLanguageManager.TranslateUi(
                    "Termination requested: {0} running, {1} pending."), stopped, cancelledPending));
            return stopped + cancelledPending;
        }

[MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsValid(uint serial)
        {
            return serial > 0 && serial < 0x80000000;
        }

public Entity Get(uint serial)

        {

            Entity ent;



            if (SerialHelper.IsMobile(serial))

            {

                ent = Mobiles.Get(serial);



                if (ent == null)

                {

                    ent = Items.Get(serial);

                }

            }

            else

            {

                ent = Items.Get(serial);



                if (ent == null)

                {

                    ent = Mobiles.Get(serial);

                }

            }



            if (ent != null && ent.IsDestroyed)

            {

                ent = null;

            }



            return ent;

        }

public void ActivateHandle() => bridge.ActivateHandle();

private int AddUserStatic(int graphic, int x, int y, int z, int hue, int map)

        {

            if (graphic < 0 || graphic > ushort.MaxValue || x < 0 || y < 0 || map < 0)

                return -1;

            int id = state.NextUserStaticId++;

            state.UserStatics[id] = string.Join("|", graphic, x, y, z, hue, map);

            bridge.AddUserStatic(id, graphic, x, y, z, hue, map);

            return id;

        }

public void BandageSelf()

        {

            var foundBandages = FindType(new InjectionValue(0x0e21), new InjectionValue(0), new InjectionValue("my"));

            if (foundBandages != string.Empty)

            {

                WaitTargetSelf();

                UseObject(foundBandages);

            }

            else

                SystemMessage("No bandages found.");

        }

public void CharPrint(InjectionValue id, InjectionValue color, InjectionValue msg) 

            => CharPrint(GetObject(id), NumberConversions.ToInt(color), (string)msg);

public void ConsolePrint(InjectionValue msg) => bridge.Print(msg.ToString());

private int Equip(string name, RuntimeDictionary<EquipSet> equipSets, int[] supportedLayers, string successMessage, string missingMessage)

        {

            if (equipSets.TryGet(name, out var equipSet))

            {

                if (bridge.IsOnline() == 0)

                {

                    SystemMessage("Equipment set requires an active connection.");

                    return 0;

                }

                bool success = true;

                foreach (var layer in supportedLayers)

                {

                    var id = equipSet.GetAtLayer(layer);

                    int current = bridge.ObjAtLayer(layer);

                    if (id == current) continue;

                    int accepted;

                    if (id != 0)

                    {

                        if (bridge is IApiEquipmentSetActions actions)

                            accepted = actions.EquipSavedItem(layer, id, state.UseEquipForDress != 0);

                        else if (state.UseEquipForDress != 0)

                            accepted = bridge.Equip(layer, id);

                        else

                        {

                            // Older bridge implementations expose only a void

                            // use call; successful dispatch is all they report.

                            bridge.UseObject(id);

                            accepted = 1;

                        }

                    }

                    else

                    {

                        accepted = bridge is IApiEquipmentActions actions

                            ? actions.UnequipItem(current) : bridge.Unequip(layer);

                    }

                    success &= accepted != 0;

                    if (accepted != 0 && state.DressSpeed > 0)

                        injectionApi.Wait(state.DressSpeed);

                }



                SystemMessage(success ? successMessage : "Some equipment set requests were rejected.");

                return success ? 1 : 0;

            }



            SystemMessage(missingMessage);

            return 0;

        }

case "addgumpignorebyid": state.IgnoredGumpIds.Add(Arg(0)); return InjectionValue.Unit;

case "attack": bridge.Attack(Arg(0)); return InjectionValue.Unit;

case "closemenu": bridge.CloseMenu(); return InjectionValue.Unit;

case "dresssavedset":

                case "equipdressset": return new InjectionValue(Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress."));

case "finddistance":

                    if (arguments.Length > 0) { bridge.SetFindDistance(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(bridge.GetFindDistance());

case "getautoselldelay":

                    return new InjectionValue(bridge.GetAutoSellDelay());

case "getfounditems":

                    return new InjectionValue(bridge.GetFoundItems().Select(serial => new InjectionValue(serial)).ToArray());

case "getgumpserial": return new InjectionValue(bridge.GetGumpSerial(Arg(0)));

case "gethp": return new InjectionValue(bridge.GetHP(Arg(0, bridge.Self)));

case "getmaxhp": return new InjectionValue(bridge.GetMaxHP(Arg(0, bridge.Self)));

case "getmaxstam": return new InjectionValue(bridge.GetMaxStamina(Arg(0, bridge.Self)));

case "getscriptpath": return new InjectionValue(bridge.GetScriptPath(Arg(0)));

case "getscriptslist": return new InjectionValue(bridge.GetScriptsList().Select(value => new InjectionValue(value)).ToArray());

case "globalchatjoinchannel": bridge.GlobalChatJoin(Text(0)); return InjectionValue.Unit;

case "gumpautocheckbox": QueueGumpControl("checkbox", Arg(0), Text(1)); return InjectionValue.Unit;

case "http_body": return new InjectionValue(httpBody);

case "ispoisoned": return new InjectionValue(bridge.Poisoned(Arg(0, bridge.Self)));

case "maxstam": return new InjectionValue(bridge.MaxStamina);

case "objatlayer":

                    return new InjectionValue(arguments[0].Kind == InjectionValueKind.String

                        ? GetObject(ObjAtLayer(Text(0))) : bridge.ObjAtLayer(Arg(0)));

case "targettotile":

                    bridge.TargetToTile(Arg(0), Arg(1), Arg(2), Arg(3)); return InjectionValue.Unit;

case "togglefly": bridge.ToggleFly(); return InjectionValue.Unit;

case "useselfpaperdollscroll": bridge.UseObject(bridge.Self); return InjectionValue.Unit;

case "waitforclienttargetresponse": return new InjectionValue(bridge.WaitForClientTargetResponse(Arg(0)));

case "lastattack":

                case "wartargetid": return new InjectionValue(bridge.LastAttack);

private InjectionValue ExecuteEmptyContainer(InjectionValue[] values)

        {

            int delay = Math.Max(0, NumberConversions.ToInt(values[0]));

            int source = values.Length > 1 ? ResolveTransferObject(values[1]) : 0;

            if (source == 0) source = bridge.SelectContainer();

            if (source == 0) return InjectionValue.Zero;

            int destination = values.Length > 2 ? ResolveTransferDestination(values[2]) : bridge.Backpack;

            return new InjectionValue(bridge.EmptyContainer(source, destination, delay));

        }

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

case "loadhotkeys": bridge.LoadHotkeys(); break;

public int FindCount(InjectionValue id) => bridge.GetQuantity(GetObject(id));

public string FindType(InjectionValue type, InjectionValue color, InjectionValue container, InjectionValue range)

        {

            if (container.Kind == InjectionValueKind.String && container.String.Equals("my", StringComparison.OrdinalIgnoreCase))

                return FindType(ResolveType(type), NumberConversions.ToInt(color), ConvertContainer(container), NumberConversions.ToInt(range), true);

            else

                return FindType(ResolveType(type), NumberConversions.ToInt(color), ConvertContainer(container), NumberConversions.ToInt(range), false);

        }

public int GetDistance(int id) => bridge.GetDistance(id);

public string GetEasyUO(InjectionValue number) => bridge.GetEasyUO(NumberConversions.ToInt(number));

public string GetFoundedTextColor() => selectedJournalEntry != null ? $"0x{selectedJournalEntry.Color:X4}" : "0x0000";

public int GetNotoriety(int id) => bridge.GetNotoriety(id);

public int GetX(string id) => GetX(GetObject(id));

public int GetY() => GetY("self");

public int Grab(int amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });