bool flag = true;
bool other = false;

address owner = msg.sender;
address zero = address(0);

address treasury = 0x1234567890abcdef1234567890abcdef12345678;

string name = "SolScript";
string empty = "";

bytes32 hash = keccak256("data");
bytes4 selector = bytes4(keccak256("transfer(address,uint256)"));

bytes data;

data.push(0x01);       // Append byte
uint256 len = data.length;
bytes1 first = data[0];

uint256[5] fixed;

fixed[0] = 1;
fixed[4] = 5;
uint256 len = fixed.length;  // Always 5

uint256[] dynamic;

dynamic.push(1);           // Append
dynamic.push(2);
uint256 val = dynamic[0];  // Access
uint256 last = dynamic.pop();  // Remove last
uint256 len = dynamic.length;
delete dynamic[0];         // Reset to 0

uint256[] memory arr = [1, 2, 3, 4, 5];

mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowances;
mapping(uint256 => User) users;

balances[msg.sender] = 100;
uint256 bal = balances[msg.sender];

struct User {
    address wallet;
    uint256 balance;
    bool active;
    string name;
}

User public admin;
User[] public users;
mapping(address => User) public userByAddress;

// Named fields
User memory u1 = User({
    wallet: msg.sender,
    balance: 0,
    active: true,
    name: "Alice"
});

// Positional
User memory u2 = User(msg.sender, 0, true, "Bob");

admin.balance = 100;
string memory name = admin.name;

enum Status {
    Pending,    // 0
    Active,     // 1
    Completed,  // 2
    Cancelled   // 3
}

Status public state = Status.Pending;

function activate() public {
    state = Status.Active;
}

function isActive() public view returns (bool) {
    return state == Status.Active;
}

uint8 value = uint8(Status.Active);  // 1
Status s = Status(1);  // Status.Active

// State variables are storage by default
uint256 public value;
mapping(address => uint256) public balances;

function process() public {
    uint256[] memory temp = new uint256[](10);
    // temp only exists during this call
}

function process(uint256[] calldata data) external {
    // data is read-only, more gas efficient
}

uint8 small = 100;
uint256 large = small;  // OK - implicit

uint256 large = 1000;
uint8 small = uint8(large);  // Explicit cast (may truncate!)

int256 signed = -100;
uint256 unsigned = uint256(signed);  // Be careful!

// From bytes32
bytes32 data = 0x1234...;
address addr = address(uint160(uint256(data)));

type TokenId is uint256;
type Amount is uint128;
type Percentage is uint8;

function transfer(TokenId id, Amount amount) public {
    // Improved readability
}