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

contract Implementation {
    address public owner;  // Slot 0
    uint256 public data;   // Slot 1

    function changeOwner(address _o) external { owner = _o; }
    function changeData(uint256 _d)  external { data  = _d; }
}

contract ProxyPuppet {
    address public implementation;  // Slot 0
    address public admin;           // Slot 1  <- TARGET
    bool    public solved;
    address public deployer;
    bytes32 private flag;

    constructor(address _impl, bytes32 _flag) {
        implementation = _impl;
        admin          = msg.sender;
        deployer       = msg.sender;
        flag           = _flag;
    }

    function isSolved() external returns (bool) {
        if (admin != deployer && !solved) solved = true;
        return solved;
    }

    function getFlag() external view returns (string memory) {
        require(solved, "Solve the challenge first to get the flag!");
        return string(abi.encodePacked(flag));
    }

    fallback() external payable {
        address impl = implementation;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), impl, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
    receive() external payable {}
}