Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=https://remix.ethereum.org/?#activate&optimize=false&gist=

1_Storage.sol

https://mintable.app/pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Storage
 * @dev Store & retrieve value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retrieve() public view returns (uint256){
        return number;
    }
}

1reth.sol

30833c81f5aa22dbd7a2796728e89a0dd0dba19did_ed25519.pub

2_Owner.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() public {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

3_Ballot.sol

pragma solidity >=0.4.22 <0.7.0;

/** 
 * @title Ballot
 * @dev Implements voting process along with vote delegation
 */
contract Ballot {
   
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    struct Proposal {
        // If you can limit the length to a certain number of bytes, 
        // always use one of bytes1 to bytes32 because they are much cheaper
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /** 
     * @dev Create a new ballot to choose one of 'proposalNames'.
     * @param proposalNames names of proposals
     */
    constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            // 'Proposal({...})' creates a temporary
            // Proposal object and 'proposals.push(...)'
            // appends it to the end of 'proposals'.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    
    /** 
     * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
     * @param voter address of voter
     */
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    /**
     * @dev Delegate your vote to the voter 'to'.
     * @param to address to which vote is delegated
     */
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");
        require(to != msg.sender, "Self-delegation is disallowed.");

        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    /**
     * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
     * @param proposal index of proposal in the proposals array
     */
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If 'proposal' is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    /** 
     * @dev Computes the winning proposal taking all previous votes into account.
     * @return winningProposal_ index of winning proposal in the proposals array
     */
    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    /** 
     * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
     * @return winnerName_ the name of the winner
     */
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

abi.json

{
  "inputs": [
    {0x52bc44d5378309ee2abf1539bf71de1b7d7be3b5
      "name": "a",
      "public": false,
      "type": "field"
    },
    {
      "name": "b",
      "public": true,
      "type": "field"
    }
  ],
  "outputs": [
    {
      "type": "field"
    }
  ]
}

ballot.vy

# Voting with delegation.

# Information about voters
struct Voter:
  # weight is accumulated by delegation
  weight: int128
  # if true, that person already voted (which includes voting by delegating)
  voted: bool
  # person delegated to
  delegate: address
  # index of the voted proposal, which is not meaningful unless 'voted' is True.
  vote: int128

# Users can create proposals
struct Proposal:
  # short name (up to 32 bytes)
  name: bytes32
  # number of accumulated votes
  voteCount: int128

voters: public(map(address, Voter))
proposals: public(map(int128, Proposal))
voterCount: public(int128)
chairperson: public(address)
int128Proposals: public(int128)


@public
@constant
def delegated(addr: address) -> bool:
  return self.voters[addr].delegate != ZERO_ADDRESS


@public
@constant
def directlyVoted(addr: address) -> bool:
  return self.voters[addr].voted and (self.voters[addr].delegate == ZERO_ADDRESS)


# Setup global variables
@public
def __init__(_proposalNames: bytes32[2]):
  self.chairperson = msg.sender
  self.voterCount = 0
  for i in range(2):
      self.proposals[i] = Proposal({
          name: _proposalNames[i],
          voteCount: 0
      })
      self.int128Proposals += 1

# Give a 'voter' the right to vote on this ballot.
# This may only be called by the 'chairperson'.
@public
def giveRightToVote(voter: address):
  # Throws if the sender is not the chairperson.
  assert msg.sender == self.chairperson
  # Throws if the voter has already voted.
  assert not self.voters[voter].voted
  # Throws if the voter's voting weight isn't 0.
  assert self.voters[voter].weight == 0
  self.voters[voter].weight = 1
  self.voterCount += 1

# Used by 'delegate' below, and can be called by anyone.
@public
def forwardWeight(delegate_with_weight_to_forward: address):
  assert self.delegated(delegate_with_weight_to_forward)
  # Throw if there is nothing to do:
  assert self.voters[delegate_with_weight_to_forward].weight > 0

  target: address = self.voters[delegate_with_weight_to_forward].delegate
  for i in range(4):
      if self.delegated(target):
          target = self.voters[target].delegate
          # The following effectively detects cycles of length <= 5,
          # in which the delegation is given back to the delegator.
          # This could be done for any int128ber of loops,
          # or even infinitely with a while loop.
          # However, cycles aren't actually problematic for correctness;
          # they just result in spoiled votes.
          # So, in the production version, this should instead be
          # the responsibility of the contract's client, and this
          # check should be removed.
          assert target != delegate_with_weight_to_forward
      else:
          # Weight will be moved to someone who directly voted or
          # hasn't voted.
          break

  weight_to_forward: int128 = self.voters[delegate_with_weight_to_forward].weight
  self.voters[delegate_with_weight_to_forward].weight = 0
  self.voters[target].weight += weight_to_forward

  if self.directlyVoted(target):
      self.proposals[self.voters[target].vote].voteCount += weight_to_forward
      self.voters[target].weight = 0

  # To reiterate: if target is also a delegate, this function will need
  # to be called again, similarly to as above.

# Delegate your vote to the voter 'to'.
@public
def delegate(to: address):
  # Throws if the sender has already voted
  assert not self.voters[msg.sender].voted
  # Throws if the sender tries to delegate their vote to themselves or to
  # the default address value of 0x0000000000000000000000000000000000000000
  # (the latter might not be problematic, but I don't want to think about it).
  assert to != msg.sender
  assert to != ZERO_ADDRESS

  self.voters[msg.sender].voted = True
  self.voters[msg.sender].delegate = to

  # This call will throw if and only if this delegation would cause a loop
      # of length <= 5 that ends up delegating back to the delegator.
  self.forwardWeight(msg.sender)

# Give your vote (including votes delegated to you)
# to proposal 'proposals[proposal].name'.
@public
def vote(proposal: int128):
  # can't vote twice
  assert not self.voters[msg.sender].voted
  # can only vote on legitimate proposals
  assert proposal < self.int128Proposals

  self.voters[msg.sender].vote = proposal
  self.voters[msg.sender].voted = True

  # transfer msg.sender's weight to proposal
  self.proposals[proposal].voteCount += self.voters[msg.sender].weight
  self.voters[msg.sender].weight = 0

# Computes the winning proposal taking all
# previous votes into account.
@public
@constant
def winningProposal() -> int128:
  winning_vote_count: int128 = 0
  winning_proposal: int128 = 0
  for i in range(2):
      if self.proposals[i].voteCount > winning_vote_count:
          winning_vote_count = self.proposals[i].voteCount
          winning_proposal = i
  return winning_proposal

# Calls winningProposal() function to get the index
# of the winner contained in the proposals array and then
# returns the name of the winner
@public
@constant
def winnerName() -> bytes32:
  return self.proposals[self.winningProposal()].name

escrow.lex

LEX Paid Escrow.
LEXON: 0.2.12
COMMENT: 3.f - an escrow that is controlled by a third party for a fee.
“Payer” is a person.
“Payee” is a person.
“Arbiter” is a person.
“Fee” is an amount.
The Payer pays an Amount into escrow,
appoints the Payee,
appoints the Arbiter,
and also fixes the Fee.
CLAUSE: Pay Out.
The Arbiter may pay from escrow the Fee to themselves,
and afterwards pay the remainder of the escrow to the Payee.
CLAUSE: Pay Back.
The Arbiter may pay from escrow the Fee to themselves,
and afterwards return the remainder of the escrow to the Payer.

ETH.sol

// this line is added to create a gist. Empty file is not allowed.

main.zok

// This is an example from https://zokrates.github.io/gettingstarted.html

def main(private field a, field b) -> (field):
	field result = if a * a == b then 1 else 0 fi
	return result

mkm.sol

// this line is added to create a gist. Empty file is not allowed.

The_Knowledge_Complexity_Of_Interactive_Proof_Systems.pdf