Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.30;

/// @notice An ultra-optimized ERC20 test
contract tealWallpaper {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Thrown when caller is not authorized for owner-only functions
    error Unauthorized();
    /// @dev Thrown when account has insufficient balance for operation
    error InsufficientBalance();
    /// @dev Thrown when spender has insufficient allowance for operation
    error InsufficientAllowance();
    /// @dev Thrown when attempting to transfer to or from zero address
    error InvalidAddress();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          CONSTANTS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Token name with elon
    string public constant name = unicode"teal pigment";
    /// @notice Token symbol with elon
    string public constant symbol = unicode"Teal Wallpaper";

    /// @notice Number of decimals for token amounts
    uint8 public constant decimals = 18;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           STORAGE                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Total token supply
    /// @dev Storage slot 0
    uint256 public totalSupply;

    /// @notice Contract owner address
    /// @dev Storage slot 1
    address public owner;

    /// @notice Balance of each account
    /// @dev Storage slot 2 - mapping(address => uint256)
    mapping(address => uint256) public balanceOf;

    /// @notice Allowance granted by owner to spender
    /// @dev Storage slot 3 - mapping(address => mapping(address => uint256))
    mapping(address => mapping(address => uint256)) public allowance;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          MODIFIERS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Restricts function access to contract owner only
    modifier onlyOwner() {
        if (msg.sender != owner) revert Unauthorized();
        _;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTRUCTOR                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Initializes contract and sets deployer as owner
    /// @dev Uses assembly to set owner in storage slot 1
    constructor() payable {
        assembly {
            sstore(1, caller())
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ERC20 OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Transfers tokens from caller to recipient
    /// @dev Uses assembly for gas-optimized execution with overflow checks
    /// @param to Recipient address
    /// @param amount Amount of tokens to transfer
    /// @return success True if transfer succeeded
    function transfer(address to, uint256 amount) public returns (bool success) {
        assembly {
            // Cache caller for gas savings
            let sender := caller()
            
            // Revert if recipient is zero address
            if iszero(to) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }
            
            // Load sender balance: keccak256(abi.encode(sender, 2))
            mstore(0x00, sender)
            mstore(0x20, 2)
            let senderBalanceSlot := keccak256(0x00, 0x40)
            let senderBalance := sload(senderBalanceSlot)
            
            // Revert if insufficient balance
            if gt(amount, senderBalance) {
                mstore(0x00, 0xf4d678b8) // InsufficientBalance()
                revert(0x1c, 0x04)
            }
            
            // Update sender balance (checked math via gt above)
            sstore(senderBalanceSlot, sub(senderBalance, amount))
            
            // Load and update recipient balance: keccak256(abi.encode(to, 2))
            mstore(0x00, to)
            mstore(0x20, 2)
            let recipientBalanceSlot := keccak256(0x00, 0x40)
            let recipientBalance := sload(recipientBalanceSlot)
            
            // Check for overflow in recipient balance
            let newRecipientBalance := add(recipientBalance, amount)
            if lt(newRecipientBalance, recipientBalance) {
                // Overflow protection
                revert(0, 0)
            }
            
            sstore(recipientBalanceSlot, newRecipientBalance)
            
            // Emit Transfer(sender, to, amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                sender, 
                to
            )
        }
        return true;
    }

    /// @notice Transfers tokens from one address to another using allowance
    /// @dev Supports infinite approval pattern (max uint256 allowance is not decreased)
    /// @param from Token owner address
    /// @param to Recipient address
    /// @param amount Amount of tokens to transfer
    /// @return success True if transfer succeeded
    function transferFrom(address from, address to, uint256 amount) public returns (bool success) {
        assembly {
            let spender := caller()
            
            // Revert if from or to is zero address
            if iszero(from) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }
            if iszero(to) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }

            // Compute allowance slot: keccak256(spender, keccak256(from, 3))
            mstore(0x00, from)
            mstore(0x20, 3)
            let innerSlot := keccak256(0x00, 0x40)
            mstore(0x00, spender)
            mstore(0x20, innerSlot)
            let allowanceSlot := keccak256(0x00, 0x40)
            let currentAllowance := sload(allowanceSlot)

            // Check and update allowance (skip if max uint256 for infinite approval)
            if iszero(eq(currentAllowance, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                if lt(currentAllowance, amount) {
                    mstore(0x00, 0x13be252b) // InsufficientAllowance()
                    revert(0x1c, 0x04)
                }
                sstore(allowanceSlot, sub(currentAllowance, amount))
            }

            // Load from balance: keccak256(abi.encode(from, 2))
            mstore(0x00, from)
            mstore(0x20, 2)
            let fromBalanceSlot := keccak256(0x00, 0x40)
            let fromBalance := sload(fromBalanceSlot)

            // Revert if insufficient balance
            if lt(fromBalance, amount) {
                mstore(0x00, 0xf4d678b8) // InsufficientBalance()
                revert(0x1c, 0x04)
            }

            // Update from balance
            sstore(fromBalanceSlot, sub(fromBalance, amount))

            // Load and update recipient balance: keccak256(abi.encode(to, 2))
            mstore(0x00, to)
            mstore(0x20, 2)
            let toBalanceSlot := keccak256(0x00, 0x40)
            let toBalance := sload(toBalanceSlot)
            
            // Check for overflow
            let newToBalance := add(toBalance, amount)
            if lt(newToBalance, toBalance) {
                revert(0, 0)
            }
            
            sstore(toBalanceSlot, newToBalance)

            // Emit Transfer(from, to, amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                from, 
                to
            )
        }
        return true;
    }

    /// @notice Approves spender to transfer tokens on behalf of caller
    /// @dev Setting amount to max uint256 creates infinite approval
    /// @param spender Address authorized to spend tokens
    /// @param amount Maximum amount spender can transfer
    /// @return success True if approval succeeded
    function approve(address spender, uint256 amount) public returns (bool success) {
        assembly {
            let owner_ := caller()

            // Compute allowance slot: keccak256(spender, keccak256(owner, 3))
            mstore(0x00, owner_)
            mstore(0x20, 3)
            let innerSlot := keccak256(0x00, 0x40)
            mstore(0x00, spender)
            mstore(0x20, innerSlot)
            let allowanceSlot := keccak256(0x00, 0x40)

            // Store allowance
            sstore(allowanceSlot, amount)

            // Emit Approval(owner, spender, amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925,
                owner_, 
                spender
            )
        }
        return true;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MINT / BURN                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Mints new tokens to specified address
    /// @dev Only callable by owner. Increases total supply
    /// @param to Recipient address for minted tokens
    /// @param amount Amount of tokens to mint
    function mint(address to, uint256 amount) public onlyOwner {
        assembly {
            // Revert if recipient is zero address
            if iszero(to) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }
            
            // Update total supply with overflow check
            let totalSupplyBefore := sload(0x00)
            let totalSupplyAfter := add(totalSupplyBefore, amount)
            if lt(totalSupplyAfter, totalSupplyBefore) {
                // Overflow in total supply
                revert(0, 0)
            }
            sstore(0x00, totalSupplyAfter)

            // Update recipient balance: keccak256(abi.encode(to, 2))
            mstore(0x00, to)
            mstore(0x20, 2)
            let toBalanceSlot := keccak256(0x00, 0x40)
            let toBalance := sload(toBalanceSlot)
            
            // Check for overflow
            let newBalance := add(toBalance, amount)
            if lt(newBalance, toBalance) {
                revert(0, 0)
            }
            
            sstore(toBalanceSlot, newBalance)

            // Emit Transfer(address(0), to, amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                0x0000000000000000000000000000000000000000, 
                to
            )
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OWNERSHIP                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Transfers ownership to new address
    /// @dev Only callable by current owner
    /// @param newOwner Address of new owner
    function transferOwnership(address newOwner) public onlyOwner {
        assembly {
            // Revert if new owner is zero address
            if iszero(newOwner) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }
            
            let previousOwner := caller()
            
            // Update owner storage slot
            sstore(1, newOwner)

            // Emit OwnershipTransferred(previousOwner, newOwner)
            log3(
                0x00, 
                0x00, 
                0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, // keccak256("OwnershipTransferred(address,address)")
                previousOwner, 
                newOwner
            )
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                            BURN                            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @notice Burns tokens from caller's balance
    /// @dev Decreases total supply
    /// @param amount Amount of tokens to burn
    function burn(uint256 amount) public {
        assembly {
            let sender := caller()

            // Load sender balance: keccak256(abi.encode(sender, 2))
            mstore(0x00, sender)
            mstore(0x20, 2)
            let senderBalanceSlot := keccak256(0x00, 0x40)
            let senderBalance := sload(senderBalanceSlot)

            // Revert if insufficient balance
            if lt(senderBalance, amount) {
                mstore(0x00, 0xf4d678b8) // InsufficientBalance()
                revert(0x1c, 0x04)
            }

            // Update sender balance
            sstore(senderBalanceSlot, sub(senderBalance, amount))

            // Update total supply (underflow impossible due to balance check)
            let totalSupplyBefore := sload(0x00)
            sstore(0x00, sub(totalSupplyBefore, amount))

            // Emit Transfer(sender, address(0), amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                sender, 
                0x0000000000000000000000000000000000000000
            )
        }
    }

    /// @notice Burns tokens from specified address using caller's allowance
    /// @dev Decreases both allowance and total supply
    /// @param from Address to burn tokens from
    /// @param amount Amount of tokens to burn
    function burnFrom(address from, uint256 amount) public {
        assembly {
            let spender := caller()
            
            // Revert if from is zero address
            if iszero(from) {
                mstore(0x00, 0xc5723b51) // InvalidAddress()
                revert(0x1c, 0x04)
            }

            // Compute and check allowance: keccak256(spender, keccak256(from, 3))
            mstore(0x00, from)
            mstore(0x20, 3)
            let innerSlot := keccak256(0x00, 0x40)
            mstore(0x00, spender)
            mstore(0x20, innerSlot)
            let allowanceSlot := keccak256(0x00, 0x40)
            let currentAllowance := sload(allowanceSlot)

            // Update allowance (skip if max uint256)
            if iszero(eq(currentAllowance, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                if lt(currentAllowance, amount) {
                    mstore(0x00, 0x13be252b) // InsufficientAllowance()
                    revert(0x1c, 0x04)
                }
                sstore(allowanceSlot, sub(currentAllowance, amount))
            }

            // Load from balance: keccak256(abi.encode(from, 2))
            mstore(0x00, from)
            mstore(0x20, 2)
            let fromBalanceSlot := keccak256(0x00, 0x40)
            let fromBalance := sload(fromBalanceSlot)

            // Revert if insufficient balance
            if lt(fromBalance, amount) {
                mstore(0x00, 0xf4d678b8) // InsufficientBalance()
                revert(0x1c, 0x04)
            }

            // Update from balance
            sstore(fromBalanceSlot, sub(fromBalance, amount))

            // Update total supply
            let totalSupplyBefore := sload(0x00)
            sstore(0x00, sub(totalSupplyBefore, amount))

            // Emit Transfer(from, address(0), amount)
            mstore(0x00, amount)
            log3(
                0x00, 
                0x20, 
                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef,
                from, 
                0x0000000000000000000000000000000000000000
            )
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                            EVENTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when tokens are approved for spending
    /// @param owner Token owner granting approval
    /// @param spender Address granted spending rights
    /// @param amount Amount of tokens approved
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev Emitted when tokens are transferred
    /// @param from Sender address (zero address for minting)
    /// @param to Recipient address (zero address for burning)
    /// @param amount Amount of tokens transferred
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @dev Emitted when ownership is transferred
    /// @param previousOwner Previous owner address
    /// @param newOwner New owner address
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "remappings": []
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523360015561078a806100155f395ff3fe608060405234801561000f575f5ffd5b50600436106100e5575f3560e01c806370a082311161008857806395d89b411161006357806395d89b4114610215578063a9059cbb14610242578063dd62ed3e14610255578063f2fde38b1461027f575f5ffd5b806370a08231146101b857806379cc6790146101d75780638da5cb5b146101ea575f5ffd5b806323b872dd116100c357806323b872dd14610163578063313ce5671461017657806340c10f191461019057806342966c68146101a5575f5ffd5b806306fdde03146100e9578063095ea7b31461012a57806318160ddd1461014d575b5f5ffd5b6101146040518060400160405280600c81526020016b1d19585b081c1a59db595b9d60a21b81525081565b604051610121919061061a565b60405180910390f35b61013d61013836600461066a565b610292565b6040519015158152602001610121565b6101555f5481565b604051908152602001610121565b61013d610171366004610692565b6102e4565b61017e601281565b60405160ff9091168152602001610121565b6101a361019e36600461066a565b6103b7565b005b6101a36101b33660046106cc565b610446565b6101556101c63660046106e3565b60026020525f908152604090205481565b6101a36101e536600461066a565b610491565b6001546101fd906001600160a01b031681565b6040516001600160a01b039091168152602001610121565b6101146040518060400160405280600e81526020016d2a32b0b6102bb0b6363830b832b960911b81525081565b61013d61025036600461066a565b61052e565b610155610263366004610703565b600360209081525f928352604080842090915290825290205481565b6101a361028d3660046106e3565b6105af565b5f33805f52600360205260405f20845f52806020525060405f2083815550825f5283817f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560205fa35060019392505050565b5f33846102f85763c5723b515f526004601cfd5b8361030a5763c5723b515f526004601cfd5b845f52600360205260405f20815f5280602052505060405f2080545f1981146103485783811015610342576313be252b5f526004601cfd5b83810382555b5050835f52600260205260405f2080548381101561036d5763f4d678b85f526004601cfd5b83900390555f838152600260205260409020805480840181811015610390575f5ffd5b808355505050815f5282845f5160206107355f395f51905f5260205fa35060019392505050565b6001546001600160a01b031633146103e1576040516282b42960e81b815260040160405180910390fd5b816103f35763c5723b515f526004601cfd5b5f5481810181811015610404575f5ffd5b805f555050815f52600260205260405f20805482810181811015610426575f5ffd5b909155505f81815282905f5160206107355f395f51905f52602082a35050565b33805f52600260205260405f2080548381101561046a5763f4d678b85f526004601cfd5b83900390555f80548390038155828152815f5160206107355f395f51905f52602083a35050565b33826104a45763c5723b515f526004601cfd5b825f52600360205260405f20815f5280602052505060405f2080545f1981146104e257828110156104dc576313be252b5f526004601cfd5b82810382555b5050815f52600260205260405f208054828110156105075763f4d678b85f526004601cfd5b82900390555f80548290038155818152825f5160206107355f395f51905f52602083a35050565b5f33836105425763c5723b515f526004601cfd5b805f52600260205260405f208054808511156105655763f4d678b85f526004601cfd5b84900390555f848152600260205260409020805480850181811015610588575f5ffd5b808355505050825f5283815f5160206107355f395f51905f5260205fa35060019392505050565b6001546001600160a01b031633146105d9576040516282b42960e81b815260040160405180910390fd5b806105eb5763c5723b515f526004601cfd5b338160015581817f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f5fa35050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b80356001600160a01b0381168114610665575f5ffd5b919050565b5f5f6040838503121561067b575f5ffd5b6106848361064f565b946020939093013593505050565b5f5f5f606084860312156106a4575f5ffd5b6106ad8461064f565b92506106bb6020850161064f565b929592945050506040919091013590565b5f602082840312156106dc575f5ffd5b5035919050565b5f602082840312156106f3575f5ffd5b6106fc8261064f565b9392505050565b5f5f60408385031215610714575f5ffd5b61071d8361064f565b915061072b6020840161064f565b9050925092905056feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa264697066735822122083384cab79c77152777e3f0388b19d481cfb24b4b6b15396e4bcd769abf042de64736f6c634300081e0033

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