/**

kronk.vip 




Quotes 
Yzma : So, is everything ready for tonight?

Kronk : Oh, yeah. I thought we'd start off with soup and a light salad, and then see how we feel after that.

Yzma : Not the dinner. You know...

Kronk : Oh, right. The poison. The poison for Kuzco, the poison chosen especially to kill Kuzco, Kuzco's poison. That poison?

Yzma : Yes! That poison.

Kronk : Got you covered.

Yzma : Excellent. A few drops in his drink, and then I'll propose a toast, and he will be dead before dessert.

Kronk : Which is a real shame, because it's gonna be delicious.

Kuzco : Okay, I admit it. Maybe I wasn't as nice as I should have been. But, Yzma, do you really want to kill me?

Yzma : Just think of it as you're being let go, that your life's going in a different direction, that your body's part of a permanent outplacement.

Kronk : Hey, that's kinda like what he said to you when you got fired.

Yzma : I know. It's called a "cruel irony", like my dependence on you.

Waitress : Ordering. Three pork combos, extra bacon on the side, two chili cheese samplers, a basket of liver and onion rings, a catch of the day, and a steak cut in the shape of a trout. You got all that, honey?

Kronk : Three oinkers wearing pants, plate of hot air, basket of Grandma's breakfast and change the bull to a gill, got it.

[Yzma and Kuzco never see each other. When one exits, the other enters] 

Yzma : Make me the special. And hold the gravy!

Kronk : Check. Pickup!

Kuzco : You know what? On second thought, make my omelette a meat pie.

Kronk : Meat pie. Check.

Yzma : Kronk! Can I order the potatoes as a side dish?

Kronk : I'll have to charge you full price.

Yzma : [annoyed]  Ooh.

Kuzco : Hey, how about a side of potatoes, my buddy?

Kronk : You got it. Want cheese on those potatoes?

Yzma : Thank you, Kronk. Cheddar will be fine.

Kronk : Cheddar spuds coming up.

Kuzco : Spuds yes, cheese no.

Kronk : Hold the cheese.

Yzma : No, I want the cheese.

Kronk : Cheese it is.

Kuzco : Cheese me no "likee."

Kronk : Cheese out.

Yzma : Cheese in!

Kronk : Ah, come on. Make up your mind!

Kuzco : Okay, okay, on second thought...

Yzma , Kuzco : ...make my potatoes a salad.

[Having accidentally turned Kuzco into a Llama instead of having him assassinated as planned] 

Yzma : Take him out of town and finish the job now!

Kronk : What about dinner?

Yzma : Kronk, this is kind of important.

Kronk : How about dessert?

Yzma : Well, I suppose there's time for dessert.

Kronk : And coffee?

Yzma : All right. A quick cup of coffee. THEN TAKE HIM OUT OF TOWN AND FINISH THE JOB!

[Kronk's Shoulder Angel and Devil debate saving Kuzco] 

Kronk's Shoulder Devil : Listen up, big guy. I got three good reasons why you should just walk away. Number one. Look at that guy! He's got that sissy stringy music thing.

Kronk's Shoulder Angel : We've been through this. It's a harp, and you know it.

Kronk's Shoulder Devil : Oh, right. That's a harp, and that's a dress.

Kronk's Shoulder Angel : Robe!

Kronk's Shoulder Devil : Reason number two. Look what I can do. Ha-ha, ha!

[does one-armed handstand] 

Kronk : But what does that have to do with anything?

Kronk's Shoulder Angel : No, no. He's got a point.

Kronk : Listen, you guys. You're sort of confusing me, so, uh, begone... or, uh, y'know, however I get rid of you guys.

Kronk's Shoulder Devil , Kronk's Shoulder Angel : That'll work.

[Angel and devil disappear] 

Yzma : Looking for this?

Yzma : [holds up the vial of human extract] 

[Kuzco and Pacha gasp] 

Kuzco : No! It can't be! How did you get back here before us?

Yzma : Uh...

[pauses] 

Yzma : ...how *did* we, Kronk?

Kronk : Well, ya got me. By all accounts, it doesn't make sense.

[Kronk holds up a map of the two parties' trails, showing Yzma's and Kronk's falling down a canyon halfway through] 

Yzma : Oh, well. Back to business.

Yzma : Kronk! Why did I think you could do this? This one simple thing! It's like I'm talking to a monkey.

Kronk's Shoulder Angel : Whoa now!

Yzma : A really, really big stupid monkey named Kronk!

Kronk's Shoulder Devil : Ouch.

Yzma : And do you want to know something else? I've never liked your spinach puffs!

[Kronk, Shoulder Angel, and Shoulder Devil all simultaneously gasp] 

Yzma : Never!

[Kronk begins to cry] 

Kronk's Shoulder Devil : That's it.

[cocks pitchfork like a gun] 

Kronk's Shoulder Devil : She's goin' down.

Kronk's Shoulder Angel : Now, now, remember, guys. From above, the wicked shall receive their just reward.

[they look up at the chandelier which is illuminated with heavenly light while angelic music plays] 

Kronk's Shoulder Angel , Kronk's Shoulder Devil , Kronk : That'll work.

[Kronk cuts the rope to the chandelier, but it falls around Yzma, instead of on her] 

Kronk : Strange. That usually works.

Yzma : And so does *this*!

[pulls lever for trap door] 

Kronk : Ah. Should've seen that coming. Whoa!

[last lines] 

Kronk : My acorn is missing.

Junior Chipmunk Class : Squeak, squeakin', squeak, squeakity.

Kronk : Did you eat the acorn?

Junior Chipmunk Class : Squeaker, squeak, squeak, squeakin'?

Kronk : You owe me a new acorn.

Junior Chipmunk Class : Squeak squeak squeak, squeak, squeaker...

[one boy nudges Yzma] 

Yzma Kitty : [sulky]  Squeakin'.

Kronk : I'm so proud of you guys.

Yzma : [after knocking Kuzco out unconscious, having turned into a Llama]  A llama? He's supposed to be *dead*.

Kronk : Yeah, weird.

Yzma : That's it, Kronk! Break the door down!

Kronk : Break it down? Are ya kidding me? This is hand-carved mahogany.

[Yzma, fired by Kuzco, smashes stone carvings of his head with a mallet] 

Yzma : Why, I practically raised him.

Kronk : Yeah, you'd think he would've turned out better.

Yzma : Yeah, go figure.

[Yzma is sleeping in a huge tent, while Kronk is in a tent so small it only covers his waist. Suddenly Kronk jerks awake] 

Kronk : The peasant, at the diner!

[pause] 

Kronk : He didn't pay his check.

[falls back asleep, but then jerks back up] 

Kronk : It's the peasant who I saw leaving the city who disappeared into the crowd with Kuzco in the back of his cart. He must have taken him back to his village, so if we find the village, we find him, and if we find him, we find Kuzco. Oh, yeah, it's all comin' together. Yzma!

[runs into her tent] 

Yzma : What?

[Yzma sits up with cold cream on her face and cucumbers on her eyes] 

Kronk : [recoiling]  Aah!

Yzma : This had better be good!

[after firing Yzma] 

Kuzco : [sing-song]  So... who's in my chaaaaaair?

Kronk : Oh, oh! I know! Yzma. Yzma's in your chair, right?

Kuzco : Very good, Kronk! Here. Get the snack.

ChiCha : So, remind me again how you're related to Pacha?

Yzma : Why, I'm his third cousin's brother's wife's step-niece's great aunt. Twice removed.

ChiCha : Uh-huh.

Yzma : Isn't that right, Kronk?

[Kronk is playing jump rope with Chaca and Tipo] 

Chaca : Ninety-nine monkeys jumping on the bed.

Kronk : One fell off and bumped his head.

Yzma : Kuzco is dead, right? Tell me Kuzco's dead. I need to hear these words.

Kronk : [nervously]  Uh, do you need to hear all those words exactly?

Yzma : [angry]  He's still *alive*?

Kronk : Well, he's not as dead as we would have hoped.

Yzma : Kronk!

Kronk : Just thought I'd give you a heads-up in case Kuzco ever came back.

Yzma : He can't come back!

Kronk : Yeah, that would be kinda awkward, especially after that lovely eulogy.

Yzma : You think? You and I are going out to find him. If he talks, we're through. Now let's move!

Yzma : [about the potion they used on Kuzco]  Let me see that vial.

[the Death Label was actually that of a Llama folded up slightly, causing confusion] 

Yzma : This isn't poison. This is extract of... llama!

Kronk : You know, in my defense, your poisons all look alike. You might think about relabeling some of them.

[Yzma and Kronk are trapped in a dark locked room in Pacha's house] 

ChiCha : What do you mean the door's stuck? Try jiggling the handle.

Yzma : There is no handle in here.

ChiCha : [holding the door handle]  There's not? Are you sure?

Yzma : All right, I've had enough of this. Tell us where the talking llama is and we'll burn your house to the ground.

Kronk : Er, don't you mean or?

Yzma : [even more angrily]  Grr, tell us where the talking llama is *or* we'll burn your house to the ground.

Chaca : Well, which is it? That sounds like a pretty crucial conjunction.

Yzma : [Believing Kuzco is dead, telling the others in the palace]  And so, it is with great sadness that we mourn the sudden departure of our beloved prince, taken from us so tragically on the very eve of his eighteenth birthday.

Kronk : [sobbing]  Poor little guy.

Yzma : His legacy will live in our hearts...

Kronk : He never had a chance.

Yzma : ...for all eternity.

[pause] 

Yzma : Well, he ain't getting any deader! Back to work.

[the palace guards begin to change the palace theming from Kuzco to Yzma] 

Yzma : Are you talking to that squirrel?

Kronk : I was a junior chipmunk, uh, and I had to be versed in all the woodland creatures.

[to squirrel] 

Kronk : Please continue.

[squirrel talks to Kronk] 

Yzma : [walking away]  Why me? Why me? Why me? Why...?

Kronk : Hey, it doesn't always have to be about you. This poor little guy's had it rough. Seems a talking llama gave him a hard time the other day.

[Yzma rushes over to them] 

Yzma : Oh, a talking llama? Do tell.

[squirrel whispers to Kronk] 

Kronk : Uh, he doesn't really wanna talk to you.

Yzma : Well, then *you* ask him.

Kronk : [sigh]  Hate being in the middle.

Kronk : [speaking squirrel]  Squeaky, uh, squeak, squeaker, squeakin'.

[the drink is poisoned] 

Yzma : Kronk, the emperor needs his... drink!

Kronk : Right. Oh...

[winks at Yzma] 

Kronk : ...riiiiiiggghhht.

[goes to grab drink and realizes that he doesn't know which one it is; takes the drinks away to pour the poison again] 

Kuzco : Hey, Kronky, everything okay back there?

Kronk : [mixing the drinks together before refilling all the cups]  Oh, uh, the drinks were a bit on the, uh...

[small explosion from each of the cups] 

Kronk : ...warm side. Hehe. Hey, did ya see that sky today? Talk about blue.

Yzma : Yes, Kronk. Riveting. A toast, to the emperor! Long live Kuzco!

Kronk : [to Yzma trying to make it sound like he's coughing]  Don't drink the wine. Poison.

Yzma : [handing him a bottle of poison]  Take it, Kronk. Oh ho ho! Feel the power.

Kronk : Oh... I can feel it.

Yzma : Our moment of triumph approaches! Ha ha ha ha ha! It's dinner time!

Kronk's Shoulder Angel : You're not just gonna let him die like that, are you?

Kronk : My shoulder angel.

Kronk's Shoulder Devil : Don't listen to that guy. He's trying to lead you down the path of righteousness. I'm gonna lead you down the path that *rocks*.

Kronk's Shoulder Angel : Oh, come off it.

Kronk's Shoulder Devil : *You* come off it.

Kronk's Shoulder Angel : You.

Kronk's Shoulder Devil : You.

Kronk's Shoulder Angel : You.

Kronk's Shoulder Devil : You infinity.

[Shoulder Angel grrs] 

Kronk : Oh, look. A golden-throated small-winged warbler. Just one more for exotic bird bingo. I am loving this.

Kronk : Hey, don't I know you?

Pacha : I... I don't think so.

Kronk : Wrestled you in high school.

Pacha : I don't remember that, no.

Kronk : Metal shop? Oh, I know, Miss Nalca's interpretive dance, two semesters. I was usually in the back because of my weak ankles. C'mon, you gotta help me out here.

Pacha : Look, I don't think we've ever met, but... I gotta go.

[Gets up] 

Kronk : Don't worry, I'll think of it!

Kronk : [trying to ease the awkward tension]  Hey, d'you see that sky today? Talk about blue.

Yzma Kitty : [after successfully getting her paws on the potion to turn her back into a human before Kuzco]  I win.

[Kronk suddenly opens up the nearby window nearby, slamming it onto Yzma, letting the potion fly into the hands of Pacha and Kuzco] 

Kronk : What are the odds of that trap door leadin' me out here?

ChiCha : As I said before, you may remember, Pacha is not here. I'll be sure to tell him you stopped by.

Yzma : Oh, would you please? That would be just great.

[knocks her cup on the floor] 

Yzma : Oops. Silly me.

ChiCha : [annoyed]  No no, allow me.

[very pregnant, tries to squat to pick up cup] 

Yzma : [joins Kronk jumping rope]  She's hiding something. When I give the word we search the house.

Kronk : Ok, but I still have 94 monkeys to go.

Kronk : Woohoo. Faster, faster! Yzma, put your hands in the air!

Kronk : [while falling down the stairs]  Back! Elbow! Shoulder!

Kronk : [to the squirrel, about Yzma]  Yeah, tell me about it. No, no, it's not you - she's not the easiest person to get close to. There's a wall there. Trust me.

*/
// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}




pragma solidity ^0.8.0;




contract KRONK is ERC20, ERC20Burnable, Ownable {
    uint256 private constant INITIAL_SUPPLY = 69000000000 * 10**18;

    constructor() ERC20("Kronk", "KRONK") {
        _mint(msg.sender, INITIAL_SUPPLY);
    }

    function distributeTokens(address distributionWallet) external onlyOwner {
        uint256 supply = balanceOf(msg.sender);
        require(supply == INITIAL_SUPPLY, "Tokens already distributed");

        _transfer(msg.sender, distributionWallet, supply);
    }
}