> For the complete documentation index, see [llms.txt](https://thryec.gitbook.io/dev-compedium/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://thryec.gitbook.io/dev-compedium/ethereum/yul/basic-operations.md).

# Basic Operations

#### Math Operations

```solidity
function add(uint x, uint y) external pure returns (uint256) {
        uint ret; 
        assembly {
            ret := add(x,y)
        }
        return ret; 
    }

    function subtract(uint x, uint y) external pure returns (uint256) {
        uint ret; 
        assembly {
            ret := sub(x,y)
        }
        return ret; 
    }

    function multiply(uint x, uint y) external pure returns (uint256) {
        uint ret; 
        assembly {
            ret := mul(x,y)
        }
        return ret; 
    }

		// Note: division rounds down 
    function divide(uint x, uint y) external pure returns (uint256) {
        uint ret; 
        assembly {
            ret := div(x,y)
        }
        return ret; 
   } 

```

#### For Loops

* There are no `else` statements in Yul

```solidity
function isPrime(uint256 x) public pure returns (bool p) {
        p = true;
        assembly {
            let halfX := add(div(x, 2), 1)
            for { let i := 2} lt(i, halfX) { i := add(i,1) } {
                if iszero(mod(x, i)) { // if the modulus of x with is zero, the number is not prime 
                    p := 0 // setting p = 0 equates to false 
                    break
                }

                i := add(i, 1)
            }
        }
    }
```

#### Comparisons

```solidity
function max(uint256 x, uint256 y) external pure returns (uint256 maximum) {
        assembly {
            if lt(x, y) {
                maximum := y
            }
            // there are no else statements in solidity 
            if iszero(lt(x, y)) { // if lt(x, y) is false, then iszero will return true because false is zero in bytecode  
                maximum := x
            }
        }
    } 

// alternatively: 
function max2(uint256 x, uint256 y) external pure returns (uint256 maximum) {
        assembly  {
            if lt(x, y) {
                maximum := y 
            } 
            if gt(x,y) {
                maximum := x
            }
        }
    }
```