coinop-logan

//A BurnablePaymet is instantiated with msg.sender as the payer, and a specified recipient.
//The payment can be instantiated with funds, and can be added to later by anyone.
//The payer can never directly recover the payment.
//The payer then can at any time choose to burn or release to the recipient any amount of funds.

pragma solidity ^0.4.1;

contract BurnablePayment {
    address public payer;
    address public recipient;

coinop-logan

//A BurnableOpenService is instantiated with a specified provider and a commitThreshold.
//The customer is not set when the contract is instantiated.

//Anyone can become the customer by calling commit() with ether >= commitThreshold.
//The customer cannot change once this commitment has made.

//The constructor is payable, so the contract can be instantiated with initial funds.
//Only the customer can fund the Service after instantiation.

//All other functions of the contract are accessible only to the customer,

coinop-logan

//A BurnableOpenPaymet is instantiated with a specified payer and a commitThreshold.
//The recipient not set when the contract is instantiated.

//The constructor is payable, so the contract can be instantiated with initial funds.
//Anyone can contribute to the payment at any time (the () function is payable).

//All behavior of the contract is directed by the payer, but
//the payer can never directly recover the payment unless he becomes the recipient.

//Anyone can become the recipient by contributing the commitThreshold.

coinop-logan

#include <windows.h>
#include <SFML/Graphics.hpp>
#include <gl/GL.h>
#include <gl/GLU.h>

void glEnable2D() {
	GLint iViewport[4];

	//get a copy of the viewport
	glGetIntegerv(GL_VIEWPORT, iViewport);

coinop-logan

module Contracts.ToastytradeSell
    exposing
        ( autorecallAvailable
        , autorecallInterval
        , autoreleaseAvailable
        , autoreleaseInterval
        , burn
        , claim
        , commit
        , depositDeadlineInterval

coinop-logan

Keybase proof

I hereby claim:

• I am coinop-logan on github.
• I am oglog (https://keybase.io/oglog) on keybase.
• I have a public key ASChRPXWYL1lE71rMFYI7Lnm4mLadzzaH_62k1hka7au7go

To claim this, I am signing this object:

coinop-logan

pragma solidity 0.5.10;

contract ERC20Interface {
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view returns (uint balance);
    function allowance(address tokenOwner, address spender) public view returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

coinop-logan

type IWorker =
    abstract member Work:  World -> World

and World =
    {Workers: IWorker List;
    Food: int;
    }

type Farmer() =
    interface IWorker with

coinop-logan

import requests, json

# SUBGRAPH_ID = 

# def apiUrl(apiKey, subgraphId):
#     return "https://gateway.thegraph.com/api/" + apiKey + "/subgraphs/id/" + subgraphId

def authdApiUrl():
    # with open('apikey','r') as f:
    #     apiKey = f.read()

coinop-logan

interpolateNymsForRendering : Float -> NymTemplate -> NymTemplate -> NymTemplate
interpolateNymsForRendering interp start end =
    { structure =
        { eyeQuadInfo =
            Result.map2
                (\startEQInfo endEQInfo ->
                    { sketchPlane =
                        --can ignore, not used in rendering
                        startEQInfo.sketchPlane
                    , eyeQuad =