Kongz contract breakdown

contract Kongz {
... 

// data structure representing each kong
struct Kong {
        uint256 genes; // the value 0 implies that it's a genesis kong
        uint256 bornAt; // when the kong got minted
    }

constructor (
string memory _name, 
string memory _symbol, 
string[] memory _names, 
uint256[] memory _ids
) public ERC721Namable(_name, _symbol, _names, _ids) {
        // cyberkongz uses heroku to host their metadata
        _setBaseURI("https://kongz.herokuapp.com/api/metadata/");
        // owner minting 3 kongz for themselves.
        _mint(msg.sender, 1001);
        _mint(msg.sender, 1002);
        _mint(msg.sender, 1003);
        // saving state of newly minted kongz
        kongz[1001] = Kong(0, block.timestamp);
        kongz[1002] = Kong(0, block.timestamp);
        kongz[1003] = Kong(0, block.timestamp);
        // emiting events for newly minted kongz.
        emit KongIncubated(1001, 0, 0);
        emit KongIncubated(1002, 0, 0);
        emit KongIncubated(1003, 0, 0);
        // handling the total supply of kongz.
        bebeCount = 3;
    }

...
}

function breed(
uint256 _sire, 
uint256 _matron
) external {

        // confirm that msg.sender owns both NFT's serving as sire and matron
        require(ownerOf(_sire) == msg.sender && ownerOf(_matron) == msg.sender);

        // classified breedManager attempts to breed kongz if breed is successful 
        // then function continues execution else it terminates.
        require(breedManager.tryBreed(_sire, _matron));

        // the equavalent amount (600 BANANA) required for breeding gets burned from
        // msg.sender balance.
        yieldToken.burn(msg.sender, BREED_PRICE);

        // update token supply after birth of baby kong
        bebeCount++;

        // create ID for new baby kong
        uint256 id = 1000 + bebeCount; // 1004

        // nice! Baby kong is also from gen 0
        kongz[id] = Kong(0, block.timestamp); // should confirm this from team.

        // msg.sender is a proud owner of a baby kong
        _mint(msg.sender, id);

        // msg.sender announces to the world his new baby kongz alongside the parents.
        emit KongIncubated(id, _matron, _sire);
    }

// @param _tokenId uint256 is the Id of kong to evolve
function evolve(
uint256 _tokenId
) external {
        require(ownerOf(_tokenId) == msg.sender);
        Kong storage kong = kongz[_tokenId];

        // kong must have a gene of 0 before it can be evolved.
        require(kong.genes == 0);

        // breedmanger tries to evolve the kong at the given tokenId.
        uint256 genes = breedManager.tryEvolve(_tokenId);

        kong.genes = genes;

        emit KongBorn(_tokenId, genes);
    }

function ascend(
uint256 _tokenId,
uint256 _genes, 
bytes calldata _sig
) external {

        // confirms that the tokenId conforms to Opensea's ID format (REF 1)
        // Opensea ID format -> 73424079983647210902572285069973579475843508985221180214989722260978404425729
        require(isValidKong(_tokenId), "Not valid Kong");

        // extracts currentId format from opensea tokenFormat (REF 2)
        uint256 id = returnCorrectId(_tokenId);

        require(keccak256(abi.encodePacked(id, _genes)).toEthSignedMessageHash().recover(_sig) == SIGNER, "Sig not valid");

        kongz[id] = Kong(_genes, block.timestamp);
        _mint(msg.sender, id);
        OPENSEA_STORE.safeTransferFrom(msg.sender, burn, _tokenId, 1, "");
        yieldToken.updateRewardOnMint(msg.sender, 1);
        balanceOG[msg.sender]++;
        emit KongAscended(id, _genes);
    }

function isValidKong(uint256 _id) pure internal returns(bool) {
        // making sure the ID fits the opensea format:
        // first 20 bytes are the maker address
        // next 7 bytes are the nft ID
        // last 5 bytes the value associated to the ID, here will always be equal to 1
        // There will only be 1000 kongz, we can fix boundaries and remove 5 ids that dont match kongz
        if (_id >> 96 != 0x000000000000000000000000a2548e7ad6cee01eeb19d49bedb359aea3d8ad1d)
            return false;
        if (_id & 0x000000000000000000000000000000000000000000000000000000ffffffffff != 1)
            return false;
        uint256 id = (_id & 0x0000000000000000000000000000000000000000ffffffffffffff0000000000) >> 40;
        if (id > 1005 || id == 262 || id == 197 || id == 75 || id == 34 || id == 18 || id == 0)
            return false;
        return true;
    }

function returnCorrectId(uint256 _id) pure internal returns(uint256) {
        _id = (_id & 0x0000000000000000000000000000000000000000ffffffffffffff0000000000) >> 40;
        if (_id > 262)
            return _id - 5;
        else if (_id > 197)
            return _id - 4;
        else if (_id > 75)
            return _id - 3;
        else if (_id > 34)
            return _id - 2;
        else if (_id > 18)
            return _id - 1;
        else
            return _id;
    }

function changeName(uint256 tokenId, string memory newName) public override {
        // msg.sender pays the cost of changing the name by burning the equivalent
      // amount of BANANAS required (300 BANANAS)
        yieldToken.burn(msg.sender, nameChangePrice);
        super.changeName(tokenId, newName);
    }

    function changeBio(uint256 tokenId, string memory _bio) public override {
        // msg.sender pays the cost of changing the bio by burning the equivalent
      // amount of BANANAS required (100 BANANAS)
        yieldToken.burn(msg.sender, BIO_CHANGE_PRICE);
        super.changeBio(tokenId, _bio);
    }