inv_shared.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2020 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "q_shared.h"

static const csi_t* CSI;

void INVSH_InitCSI (const csi_t* import)
{
    CSI = import;
}

bool invDef_t::isFloorDef () const
{
    return id == CID_FLOOR;
}

bool invDef_t::isRightDef () const
{
    return id == CID_RIGHT;
}

bool invDef_t::isLeftDef () const
{
    return id == CID_LEFT;
}

bool invDef_t::isEquipDef () const
{
    return id == CID_EQUIP;
}

bool invDef_t::isArmourDef () const
{
    return id == CID_ARMOUR;
}

static int cacheCheckToInventory = INV_DOES_NOT_FIT;

static bool INVSH_CheckShapeCollision (const uint32_t* shape, const uint32_t itemShape, const int x, const int y)
{
    /* Negative positions not allowed (all items are supposed to have at least one bit set in the first row and column) */
    if (x < 0 || y < 0) {
        Com_DPrintf(DEBUG_SHARED, "INVSH_CheckShapeCollision: x or y value negative: x=%i y=%i!\n", x, y);
        return true;
    }

    for (int i = 0; i < SHAPE_SMALL_MAX_HEIGHT; i++) {
        /* 0xFF is the length of one row in a "small shape" i.e. SHAPE_SMALL_MAX_WIDTH */
        const int itemRow = (itemShape >> (i * SHAPE_SMALL_MAX_WIDTH)) & 0xFF;
        /* Result has to be limited to 32bit (SHAPE_BIG_MAX_WIDTH) */
        const uint32_t itemRowShifted = itemRow << x;

        /* Check x maximum. */
        if (itemRowShifted >> x != itemRow)
            /* Out of bounds (32bit; a few bits of this row in itemShape were truncated) */
            return true;

        /* Check y maximum. */
        if (y + i >= SHAPE_BIG_MAX_HEIGHT && itemRow)
            /* This row (row "i" in itemShape) is outside of the max. bound and has bits in it. */
            return true;

        /* Check for collisions of the item with the big mask. */
        if (itemRowShifted & shape[y + i])
            return true;
    }

    return false;
}

static bool INVSH_CheckToInventory_shape (const Inventory* const inv, const invDef_t* container, const uint32_t itemShape, const int x, const int y, const Item* ignoredItem)
{
    static uint32_t mask[SHAPE_BIG_MAX_HEIGHT];

    assert(container);

    if (container->scroll)
        Sys_Error("INVSH_CheckToInventory_shape: No scrollable container will ever use this. This type does not support grid-packing!");

    /* check bounds */
    if (x < 0 || y < 0 || x >= SHAPE_BIG_MAX_WIDTH || y >= SHAPE_BIG_MAX_HEIGHT)
        return false;

    if (!cacheCheckToInventory) {
        /* extract shape info */
        for (int j = 0; j < SHAPE_BIG_MAX_HEIGHT; j++)
            mask[j] = ~container->shape[j];

        /* Add other items to mask. (i.e. merge their shapes at their location into the generated mask) */
        const Container& cont = inv->getContainer(container->id);
        Item* item = nullptr;
        while ((item = cont.getNextItem(item))) {
            if (ignoredItem == item)
                continue;

            if (item->rotated)
                INVSH_MergeShapes(mask, item->def()->getShapeRotated(), item->getX(), item->getY());
            else
                INVSH_MergeShapes(mask, item->def()->shape, item->getX(), item->getY());
        }
    }

    /* Test for collisions with newly generated mask. */
    if (INVSH_CheckShapeCollision(mask, itemShape, x, y))
        return false;

    /* Everything ok. */
    return true;
}

static bool INVSH_CheckShapeSmall (const uint32_t shape, const int x, const int y)
{
    if (y >= SHAPE_SMALL_MAX_HEIGHT || x >= SHAPE_SMALL_MAX_WIDTH|| x < 0 || y < 0) {
        return false;
    }

    return shape & (0x01 << (y * SHAPE_SMALL_MAX_WIDTH + x));
}

static bool INVSH_ShapeCheckPosition (const Item* item, const int x, const int y)
{
    assert(item);

    /* Check if the position is inside the shape (depending on rotation value) of the item. */
    uint32_t shape;
    if (item->rotated) {
        shape = item->def()->getShapeRotated();
    } else {
        shape = item->def()->shape;
    }

    return INVSH_CheckShapeSmall(shape, x - item->getX(), y - item->getY());
}

bool objDef_t::isCraftItem () const
{
    return craftitem.type != MAX_ACITEMS && !isDummy;
}

bool objDef_t::isBaseDefenceItem () const
{
    return craftitem.type != MAX_ACITEMS && isDummy;
}

const objDef_t* INVSH_GetItemByIDSilent (const char* id)
{
    if (!id)
        return nullptr;

    for (int i = 0; i < CSI->numODs; ++i) { /* i = item index */
        const objDef_t* item = &CSI->ods[i];
        if (Q_streq(id, item->id)) {
            return item;
        }
    }
    return nullptr;
}

const objDef_t* INVSH_GetItemByIDX (int index)
{
    if (index == NONE)
        return nullptr;

    if (index < 0 || index >= CSI->numODs)
        Sys_Error("Invalid object index given: %i", index);

    return &CSI->ods[index];
}

const objDef_t* INVSH_GetItemByID (const char* id)
{
    const objDef_t* od = INVSH_GetItemByIDSilent(id);
    if (!od)
        Com_Printf("INVSH_GetItemByID: Item \"%s\" not found.\n", id);

    return od;
}

const implantDef_t* INVSH_GetImplantForObjDef (const objDef_t* od)
{
    for (int i = 0; i < CSI->numImplants; i++) {
        const implantDef_t* id = &CSI->implants[i];
        if (id->item == od)
            return id;
    }
    Com_Printf("INVSH_GetImplantForObjDef: could not get implant for %s\n", od->id);
    return nullptr;
}

const implantDef_t* INVSH_GetImplantByIDSilent (const char* id)
{
    if (!id)
        return nullptr;

    for (int i = 0; i < CSI->numImplants; ++i) {
        const implantDef_t* item = &CSI->implants[i];
        if (Q_streq(id, item->id)) {
            return item;
        }
    }
    return nullptr;
}

const implantDef_t* INVSH_GetImplantByID (const char* id)
{
    const implantDef_t* implantDef = INVSH_GetImplantByIDSilent(id);
    if (!implantDef)
        Com_Printf("INVSH_GetImplantByID: Implant \"%s\" not found.\n", id);

    return implantDef;
}

const invDef_t* INVSH_GetInventoryDefinitionByID (const char* id)
{
    const invDef_t* container = CSI->ids;

    for (containerIndex_t i = 0; i < CID_MAX; ++container, ++i)
        if (Q_streq(id, container->name))
            return container;

    return nullptr;
}

bool objDef_t::isLoadableInWeapon (const objDef_t* weapon) const
{
    assert(weapon);

    /* check whether the weapon is only linked to itself. */
    if (this->numWeapons == 1 && this->weapons[0] == this)
        return false;

    for (int i = 0; i < this->numWeapons; i++)
        if (weapon == this->weapons[i])
            return true;

    return false;
}

/*
===============================
FIREMODE MANAGEMENT FUNCTIONS
===============================
*/

const fireDef_t* FIRESH_GetFiredef (const objDef_t* obj, const weaponFireDefIndex_t weapFdsIdx, const fireDefIndex_t fdIdx)
{
    if (weapFdsIdx < 0 || weapFdsIdx >= MAX_WEAPONS_PER_OBJDEF)
        Sys_Error("FIRESH_GetFiredef: weapFdsIdx out of bounds [%i] for item '%s'", weapFdsIdx, obj->id);
    if (fdIdx < 0 || fdIdx >= MAX_FIREDEFS_PER_WEAPON)
        Sys_Error("FIRESH_GetFiredef: fdIdx out of bounds [%i] for item '%s'", fdIdx, obj->id);
    return &obj->fd[weapFdsIdx & (MAX_WEAPONS_PER_OBJDEF - 1)][fdIdx & (MAX_FIREDEFS_PER_WEAPON - 1)];
}

void INVSH_MergeShapes (uint32_t* shape, const uint32_t itemShape, const int x, const int y)
{
    for (int i = 0; (i < SHAPE_SMALL_MAX_HEIGHT) && (y + i < SHAPE_BIG_MAX_HEIGHT); ++i)
        shape[y + i] |= ((itemShape >> i * SHAPE_SMALL_MAX_WIDTH) & 0xFF) << x;
}

bool INVSH_CheckShape (const uint32_t* shape, const int x, const int y)
{
    if (y >= SHAPE_BIG_MAX_HEIGHT || x >= SHAPE_BIG_MAX_WIDTH || x < 0 || y < 0) {
        Com_Printf("INVSH_CheckShape: Bad x or y value: (x=%i, y=%i)\n", x, y);
        return false;
    }

    const uint32_t row = shape[y];
    const int position = powf(2.0f, (float)x);
    if ((row & position) == 0)
        return false;

    return true;
}

int INVSH_ShapeSize (const uint32_t shape)
{
    int bitCounter = 0;

    for (int i = 0; i < SHAPE_SMALL_MAX_HEIGHT * SHAPE_SMALL_MAX_WIDTH; ++i)
        if (shape & (1 << i))
            ++bitCounter;

    return bitCounter;
}

static uint32_t INVSH_ShapeSetBit (uint32_t shape, const int x, const int y)
{
    if (x >= SHAPE_SMALL_MAX_WIDTH || y >= SHAPE_SMALL_MAX_HEIGHT || x < 0 || y < 0) {
        Com_Printf("INVSH_ShapeSetBit: Bad x or y value: (x=%i, y=%i)\n", x,y);
        return shape;
    }

    shape |= 0x01 << (y * SHAPE_SMALL_MAX_WIDTH + x);
    return shape;
}


uint32_t objDef_t::getShapeRotated () const
{
    uint32_t shapeNew = 0;
    int maxWidth = -1;

    for (int w = SHAPE_SMALL_MAX_WIDTH - 1; w >= 0; w--) {
        for (int h = 0; h < SHAPE_SMALL_MAX_HEIGHT; h++) {
            if (!INVSH_CheckShapeSmall(shape, w, h))
                continue;
            if (w >= SHAPE_SMALL_MAX_HEIGHT) {
                /* Object can't be rotated (code-wise), it is longer than SHAPE_SMALL_MAX_HEIGHT allows. */
                return shape;
            }

            if (maxWidth < 0)
                maxWidth = w;

            shapeNew = INVSH_ShapeSetBit(shapeNew, h, maxWidth - w);
        }
    }

    return shapeNew;
}

Item::Item ()
{
    setAmmoLeft(NONE_AMMO);
    setAmount(0);
    setAmmoDef(nullptr);
    _itemDef = nullptr;
    _x = _y = rotated = 0;
    _next = nullptr;
}

Item::Item (const objDef_t* itemDef, const objDef_t* ammo, int ammoLeft)
{
    setAmmoLeft(ammoLeft);
    setAmount(0);
    setAmmoDef(ammo);
    _itemDef = itemDef;
    _x = _y = rotated = 0;
    _next = nullptr;
}

int Item::getWeight () const
{
    int weight = def()->weight;
    if (ammoDef() && ammoDef() != def() && getAmmoLeft() > 0) {
        weight += ammoDef()->weight;
    }
    return weight;
}

bool Item::isSameAs (const Item* const other) const
{
    if (this == other)
        return true;

    if (other == nullptr)
        return false;

    if (this->def() == other->def() && this->ammoDef() == other->ammoDef() && this->getAmmoLeft() == other->getAmmoLeft())
        return true;

    return false;
}

void Item::getFirstShapePosition (int* const x, int* const y) const
{
    for (int tempX = 0; tempX < SHAPE_SMALL_MAX_HEIGHT; tempX++)
        for (int tempY = 0; tempY < SHAPE_SMALL_MAX_HEIGHT; tempY++)
            if (INVSH_ShapeCheckPosition(this, this->getX() + tempX, this->getY() + tempY)) {
                *x = tempX;
                *y = tempY;
                return;
            }

    *x = *y = NONE;
}

const fireDef_t* Item::getFiredefs () const
{
    const objDef_t* ammodef = ammoDef();
    const objDef_t* weapon = def();

    /* this weapon does not use ammo, check for
     * existing firedefs in the weapon. */
    if (weapon->numWeapons > 0)
        ammodef = def();

    if (!ammodef)
        return nullptr;

    for (int i = 0; i < ammodef->numWeapons; ++i) {     /* search the weapons that this ammo supports */
        if (weapon == ammodef->weapons[i])              /* found it ! */
            return &ammodef->fd[i][0];                  /* return the relevant part of the ammo's fireDef table */
    }

    return nullptr;
}

int Item::getNumFiredefs () const
{
    const fireDef_t* fdArray = getFiredefs();
    if (!fdArray)
        return 0;
    const objDef_t* ammodef = this->def()->numWeapons > 0 ? def() : ammoDef();
    return ammodef->numFiredefs[fdArray->weapFdsIdx];
}

const fireDef_t* Item::getSlowestFireDef () const
{
    const fireDef_t* fdArray = getFiredefs();
    int slowest = 0;

    if (fdArray == nullptr)
        return nullptr;

    for (int i = 0; i < MAX_FIREDEFS_PER_WEAPON; ++i)
        if (fdArray[i].time > fdArray[slowest].time)
            slowest = i;

    return &fdArray[slowest];
}
const fireDef_t* Item::getFastestFireDef () const
{
    const fireDef_t* fdArray = getFiredefs();
    const int fdCount = getNumFiredefs();
    int fastestTime = 999;
    int fastest = -1;

    if (fdArray == nullptr)
        return nullptr;

    for (int i = 0; i < fdCount; ++i)
        if (fastestTime > fdArray[i].time) {
            fastestTime = fdArray[i].time;
            fastest = i;
        }

    return fastest == -1 ? nullptr : &fdArray[fastest];
}

const objDef_t* Item::getReactionFireWeaponType () const
{
    if (def()) {
        const fireDef_t* fd = getFiredefs();
        if (fd && fd->reaction)
            return def();
    }

    return nullptr;
}

Container::Container ()
{
    _def = nullptr;
    _invList = nullptr;
    id = 0;
}

const invDef_t* Container::def () const
{
    return &CSI->ids[id];
}
Item* Container::getNextItem (const Item* prev) const
{
    if (!prev)
        return _invList;    /* the first one */

    return prev->getNext();
}

int Container::countItems () const
{
    int nr = 0;
    Item* item = nullptr;
    while ((item = getNextItem(item))) {
        ++nr;
    }
    return nr;
}

Inventory::Inventory ()
{
    /* This (prototype-)constructor does not work as intended. Seems like the first inventory is created before CSI is set.
     * There is the static game_inventory, static character_t, static le_t ...
     * containers[CID_LEFT]._invList = nullptr;
     * containers[CID_LEFT]._def = &CSI->ids[CID_LEFT]; */

    /* Plan B: add an 'id' member to class Container and init it here */
    init();
}

void Inventory::init ()
{
    OBJZERO(_containers);
    for (int i = 0; i < CID_MAX; ++i)
        _containers[i].id = i;
}

const Container* Inventory::_getNextCont (const Container* prev) const
{
    if (!prev)
        /* the first one */
        return &_containers[0];
    if (prev >= &_containers[CID_MAX - 1])
        /* prev was the last one */
        return nullptr;

    return ++prev;
}

const Container* Inventory::getNextCont (const Container* prev, bool inclTemp) const
{
    const Container* cont = prev;

    while ((cont = _getNextCont(cont))) {
        /* if we don't want to include the temp containers ... */
        if (!inclTemp) {
            /* ...skip them ! */
            if (cont == &_containers[CID_FLOOR])
                continue;
            if (cont == &_containers[CID_EQUIP])
                continue;
        }
        break;
    }
    return cont;
}

int Inventory::countItems () const
{
    int nr = 0;
    const Container* cont = nullptr;
    while ((cont = getNextCont(cont))) {    /* skips the temp containers */
        nr += cont->countItems();
    }
    return nr;
}
int Inventory::canHoldItem (const invDef_t* container, const objDef_t* od, const int x, const int y, const Item* ignoredItem) const
{
    assert(container);
    assert(od);

    /* armour vs item */
    if (od->isArmour()) {
        if (!container->armour && !container->all) {
            return INV_DOES_NOT_FIT;
        }
    } else if (!od->implant && container->implant) {
        return INV_DOES_NOT_FIT;
    } else if (!od->headgear && container->headgear) {
        return INV_DOES_NOT_FIT;
    } else if (container->armour) {
        return INV_DOES_NOT_FIT;
    }

    /* twohanded item */
    if (od->holdTwoHanded) {
        if ((container->isRightDef() && getContainer2(CID_LEFT)) || container->isLeftDef())
            return INV_DOES_NOT_FIT;
    }

    /* left hand is busy if right wields twohanded */
    if (container->isLeftDef()) {
        if (getContainer2(CID_RIGHT) && getContainer2(CID_RIGHT)->isHeldTwoHanded())
            return INV_DOES_NOT_FIT;

        /* can't put an item that is 'fireTwoHanded' into the left hand */
        if (od->fireTwoHanded)
            return INV_DOES_NOT_FIT;
    }

    if (container->unique) {
        const Item item(od);
        if (containsItem(container->id, &item))
            return INV_DOES_NOT_FIT;
    }

    /* Single item containers, e.g. hands or headgear. */
    if (container->single) {
        if (getContainer2(container->id)) {
            /* There is already an item. */
            return INV_DOES_NOT_FIT;
        } else {
            int fits = INV_DOES_NOT_FIT; /* equals 0 */

            if (INVSH_CheckToInventory_shape(this, container, od->shape, x, y, ignoredItem))
                fits |= INV_FITS;
            if (INVSH_CheckToInventory_shape(this, container, od->getShapeRotated(), x, y, ignoredItem))
                fits |= INV_FITS_ONLY_ROTATED;

            if (fits != INV_DOES_NOT_FIT)
                return fits;    
            Com_DPrintf(DEBUG_SHARED, "canHoldItem: INFO: Moving to 'single' container but item would not fit normally.\n");
            return INV_FITS;    
        }
    }

    /* Scrolling container have endless room, the item always fits. */
    if (container->scroll)
        return INV_FITS;

    /* Check 'grid' containers. */
    int fits = INV_DOES_NOT_FIT; /* equals 0 */
    if (INVSH_CheckToInventory_shape(this, container, od->shape, x, y, ignoredItem))
        fits |= INV_FITS;
    if (!container->isEquipDef() && !container->isFloorDef()
    && INVSH_CheckToInventory_shape(this, container, od->getShapeRotated(), x, y, ignoredItem))
        fits |= INV_FITS_ONLY_ROTATED;

    return fits;    
}

Item* Inventory::getItemAtPos (const invDef_t* container, const int x, const int y) const
{
    assert(container);

    /* Only a single item. */
    if (container->single)
        return getContainer2(container->id);

    if (container->scroll)
        Sys_Error("getItemAtPos: Scrollable containers (%i:%s) are not supported by this function.", container->id, container->name);

    /* More than one item - search for the item that is located at location x/y in this container. */
    const Container& cont = getContainer(container->id);
    Item* item = nullptr;
    while ((item = cont.getNextItem(item)))
        if (INVSH_ShapeCheckPosition(item, x, y))
            return item;

    /* Found nothing. */
    return nullptr;
}

void Inventory::findSpace (const invDef_t* container, const Item* item, int* const px, int* const py, const Item* ignoredItem) const
{
    assert(container);
    assert(!cacheCheckToInventory);

    /* Scrollable container always have room. We return a dummy location. */
    if (container->scroll) {
        *px = *py = 0;
        return;
    }

    for (int y = 0; y < SHAPE_BIG_MAX_HEIGHT; ++y) {
        for (int x = 0; x < SHAPE_BIG_MAX_WIDTH; ++x) {
            const int checkedTo = canHoldItem(container, item->def(), x, y, ignoredItem);
            if (checkedTo) {
                cacheCheckToInventory = INV_DOES_NOT_FIT;
                *px = x;
                *py = y;
                return;
            } else {
                cacheCheckToInventory = INV_FITS;
            }
        }
    }
    cacheCheckToInventory = INV_DOES_NOT_FIT;

#ifdef PARANOID
    Com_DPrintf(DEBUG_SHARED, "findSpace: no space for %s: %s in %s\n",
        item->def()->type, item->def()->id, container->name);
#endif
    *px = *py = NONE;
}

bool Inventory::canHoldItemWeight (containerIndex_t from, containerIndex_t to, const Item& item, int maxWeight) const
{
    if (CSI->ids[to].temp || !CSI->ids[from].temp)
        return true;

    const int itemWeight = item.getWeight();
    if (itemWeight < 1)
        return true;
    const bool swapArmour = item.isArmour() && getArmour();
    const int invWeight = getWeight() - (swapArmour ? getArmour()->getWeight() : 0);

    return (maxWeight < 0 || maxWeight * WEIGHT_FACTOR >= invWeight + itemWeight);
}

int Inventory::getWeight () const
{
    int weight = 0;
    const Container* cont = nullptr;
    while ((cont = getNextCont(cont))) {
        Item* item = nullptr;
        while ((item = cont->getNextItem(item))) {
            weight += item->getWeight();
        }
    }
    return weight;
}

void Inventory::setFloorContainer(Item* cont)
{
    setContainer(CID_FLOOR, cont);
}

Item* Inventory::getRightHandContainer () const
{
    return getContainer2(CID_RIGHT);
}

Item* Inventory::getLeftHandContainer () const
{
    return getContainer2(CID_LEFT);
}

Item* Inventory::getHeadgear () const
{
    return getContainer2(CID_HEADGEAR);
}

Item* Inventory::getHolsterContainer () const
{
    return getContainer2(CID_HOLSTER);
}

Item* Inventory::getFloorContainer () const
{
    return getContainer2(CID_FLOOR);
}

Item* Inventory::getEquipContainer () const
{
    return getContainer2(CID_EQUIP);
}

Item* Inventory::getImplantContainer () const
{
    return getContainer2(CID_IMPLANT);
}

Item* Inventory::getArmour () const
{
    return getContainer2(CID_ARMOUR);
}

Item* Inventory::findInContainer (const containerIndex_t contId, const Item* const searchItem) const
{
    const Container& cont = getContainer(contId);
    Item* item = nullptr;
    while ((item = cont.getNextItem(item)))
        if (item->isSameAs(searchItem)) {
            return item;
        }

    return nullptr;
}

bool Inventory::holdsReactionFireWeapon () const
{
    if (getRightHandContainer() != nullptr && getRightHandContainer()->getReactionFireWeaponType())
        return true;
    if (getLeftHandContainer() != nullptr && getLeftHandContainer()->getReactionFireWeaponType())
        return true;
    return false;
}

void equipDef_t::addClip (const Item* item)
{
    const int ammoIdx = item->ammoDef()->idx;
    numItemsLoose[ammoIdx] += item->getAmmoLeft();
    /* Accumulate loose ammo into clips */
    if (numItemsLoose[ammoIdx] >= item->def()->ammo) {
        numItemsLoose[ammoIdx] -= item->def()->ammo;
        numItems[ammoIdx]++;
    }
}

void fireDef_t::getShotOrigin (const vec3_t from, const vec3_t dir, bool crouching, vec3_t shotOrigin) const
{
    const int dv = AngleToDir((int) (atan2(dir[1], dir[0]) * todeg));
    vec3_t dvec;
    VectorCopy(dvecs[dv], dvec);
    /* get weapon position */
    VectorCopy(from, shotOrigin);
    /* adjust height: */
    if (shotOrg[1] != 0) {
        shotOrigin[2] += shotOrg[1];
        if (crouching)
            shotOrigin[2] -= EYE_STAND - PLAYER_CROUCH - 1;
    }
    /* adjust horizontal: */
    if (shotOrg[0] != 0) {
        /* get "right" and "left" of a unit(rotate dir 90 on the x-y plane): */
        const float x = dvec[1];
        const float y = -dvec[0];
        const float length = sqrt(dvec[0] * dvec[0] + dvec[1] * dvec[1]);
        /* assign adjustments: */
        shotOrigin[0] += x * shotOrg[0] / length;
        shotOrigin[1] += y * shotOrg[0] / length;
    }
}