> ## Documentation Index
> Fetch the complete documentation index at: https://voltaire.tevm.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# PUSH26 (0x79)

> Push 26-byte immediate value onto stack

<Warning>
  **This page is a placeholder.** All examples on this page are currently AI-generated and are not correct. This documentation will be completed in the future with accurate, tested examples.
</Warning>

## Overview

**Opcode:** `0x79`
**Introduced:** Frontier (EVM genesis)

PUSH26 pushes a 26-byte immediate value from the bytecode onto the stack. The 26 bytes immediately following the opcode are read and zero-padded to 256 bits.

## Specification

**Stack Input:**

```
[]
```

**Stack Output:**

```
value (uint256, 26 bytes from bytecode)
```

**Gas Cost:** 3 (GasFastestStep)

**Bytecode:** 1 byte opcode + 26 bytes immediate data

**Operation:**

```
value = read_bytes(pc + 1, 26)  // Big-endian
stack.push(value)
pc += 27
```

## Behavior

PUSH26 reads 26 bytes from bytecode starting at position `pc + 1`, interprets them as a big-endian unsigned integer, and pushes the result onto the stack.

Key characteristics:

* Reads exactly 26 bytes following opcode
* Big-endian byte order (most significant byte first)
* Zero-padded to 256 bits if less than 32 bytes
* InvalidOpcode if insufficient bytecode remaining
* PC advances by 27 (opcode + data)

## Examples

### Basic Usage

```typescript theme={null}
import { handler_0x79_PUSH26 } from '@tevm/voltaire/evm/stack/handlers';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// Bytecode with PUSH26
const bytecode = new Uint8Array([
  0x79,  // PUSH26
  0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a   // 26 bytes: 0102030405060708090a0b0c0d0e0f101112131415161718191a
]);

const frame = createFrame({
  bytecode,
  pc: 0,
  stack: [],
  gasRemaining: 1000n
});

const err = handler_0x79_PUSH26(frame);

console.log(frame.stack); // [0x0102030405060708090a0b0c0d0e0f101112131415161718191a000000000000n]
console.log(frame.pc); // 27
console.log(frame.gasRemaining); // 997n (3 gas consumed)
```

### Solidity Compilation

```solidity theme={null}
contract Example {
    // 26-byte constant
    uint208 constant VALUE = 4.113761393303015e+62;
    // PUSH26 0xffffffffffffffffffffffffffffffffffffffffffffffffffff
}
```

### Assembly Usage

```solidity theme={null}
assembly {
    // Push 26-byte value
    push26 0xffffffffffffffffffffffffffffffffffffffffffffffffffff
    
}
```

## Gas Cost

**Cost:** 3 gas (GasFastestStep)

All PUSH1-32 instructions cost the same despite different data sizes. Bytecode size impact:

* PUSH26: 27 bytes (1 opcode + 26 data)
* PUSH32: 33 bytes (1 opcode + 32 data)

**Comparison:**

| Opcode | Gas | Bytes | Use Case                  |
| ------ | --- | ----- | ------------------------- |
| PUSH0  | 2   | 1     | Zero constant (Shanghai+) |
| PUSH1  | 3   | 2     | Small numbers (0-255)     |

## Common Usage

### 26-Byte Constants

```solidity theme={null}
assembly {
    // 26-byte literal
    push26 0xabababababababababababababababababababababababababab
}
```

### Big-Endian Encoding

```typescript theme={null}
// Bytecode: PUSH26 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a
// Reads as: 0x0102030405060708090a0b0c0d0e0f101112131415161718191a

// Most significant byte first
// Byte 0: 0x01 (highest significance)
// Byte 25: 0x1a (lowest significance)
```

## Implementation

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    /**
     * Read immediate data from bytecode for PUSH operations
     */
    function readImmediate(bytecode: Uint8Array, pc: number, size: number): bigint | null {
      if (pc + 1 + size > bytecode.length) {
        return null;
      }

      let result = 0n;
      for (let i = 0; i < size; i++) {
        result = (result << 8n) | BigInt(bytecode[pc + 1 + i]);
      }
      return result;
    }

    /**
     * PUSH26 opcode (0x79) - Push 26 bytes onto stack
     *
     * Stack: [] => [value]
     * Gas: 3 (GasFastestStep)
     */
    export function handler_0x79_PUSH26(frame: FrameType): EvmError | null {
      const gasErr = consumeGas(frame, FastestStep);
      if (gasErr) return gasErr;

      const value = readImmediate(frame.bytecode, frame.pc, 26);
      if (value === null) {
        return { type: "InvalidOpcode" };
      }

      const pushErr = pushStack(frame, value);
      if (pushErr) return pushErr;

      frame.pc += 27;
      return null;
    }
    ```
  </Tab>
</Tabs>

## Edge Cases

### Insufficient Bytecode

```typescript theme={null}
// Bytecode ends before 26 bytes read
const bytecode = new Uint8Array([0x79, 0x01]); // Only 1 byte instead of 26
const frame = createFrame({ bytecode, pc: 0 });

const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "InvalidOpcode" }
```

### Stack Overflow

```typescript theme={null}
// Stack at maximum capacity
const frame = createFrame({
  stack: new Array(1024).fill(0n),
  bytecode: new Uint8Array([0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
});

const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "StackOverflow" }
```

### Out of Gas

```typescript theme={null}
// Insufficient gas
const frame = createFrame({
  gasRemaining: 2n,  // Need 3 gas
  bytecode: new Uint8Array([0x79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
});

const err = handler_0x79_PUSH26(frame);
console.log(err); // { type: "OutOfGas" }
```

### Maximum Value

```typescript theme={null}
// All bytes 0xFF
const bytecode = new Uint8Array([0x79, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
const frame = createFrame({ bytecode, pc: 0 });

handler_0x79_PUSH26(frame);
console.log(frame.stack[0]); // 0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000n
```

## References

* [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf) - Section 9.4.1 (PUSH)
* [EVM Codes - PUSH26](https://www.evm.codes/#79?fork=cancun)
* [Solidity Assembly - push26](https://docs.soliditylang.org/en/latest/yul.html#evm-opcodes)