Essentially a coin flip smart contract, written in LLL.

flip.lisp

{ (include './contract.lll'

  (def 'enough-paid (>= callvalue required-amount))
  (def 'enough-betters (>= number-of-betters required-betters))
  (def 'is-paying-out (= paying-out 1))

  (def 'minimum-bet-amount 10) ; Wei
  (def 'required-betters 10)

  (init {
    (perm 'pot)
    (perm 'result)
    (perm 'house-wins)
    (perm 'payout-to-each)
    (perm 'number-of-betters)
    (perm 'even-or-odd)
    (perm 'number-of-evens) (number-of-evens -1)
    (perm 'number-of-odds) (number-of-odds -1)
    (perm 'abstract-betters)
    (def 'betters permcount)
    (def 'betters-struct-size 2) ; (address, even-or-odd)
    (def 'betters-data-size (required-betters * betters-struct-size))
    (def 'permcount (+ permcount betters-size))
    (perm index)
  })

  (code {
    (fn 'bet {
      (when
        (|| 
          (not (enough-paid))
          (not (enough-betters))
          (is-paying-out)
        )
        (return 0 32)
      )

      (even-or-odd $4)

      (if (= even-or-odd 0)
        {
          (number-of-evens (+ number-of-evens 1))
          (abstract-betters number-of-evens)
        }
        {
          (number-of-odds (+ number-of-odds 1))
          (abstract-betters number-of-odds)
        }
      )

      (push1 (+ betters (+ (* even-or-odd betters-data-size) abstract-betters)))
      (dup1)
      [[(pop)]]: (caller)
      [[(+ (pop) 1)]]: even-or-odd
      (number-of-betters (+ number-of-betters 1))

      (pot (+ pot minimum-bet-amount))
      (result (+ result (+ even-or-odd (+ (callvalue) (caller)))))

      (if (enough-betters)
        (pay-winners)
        (return 1 32)
      )
    })


    (fn 'pay-winners {
      (when
        (not (enough-betters))
        (invalid)
      )

      (paying-out 1)

      (if
        (abstract-betters number-of-evens)
        (abstract-betters number-of-odds)
      )

      (house-wins (* pot 0.01))
      (payout-to-each (/ abstract-betters (- pot house-wins)))

      (for (index 0) (> index abstract-betters) (index (+ index 1))
        (send @@(+ index (+ betters (* even-or-odd betters-data-size))) payout-to-each)
      )

      (pot 0)
      (result 0)
      (number-of-evens -1)
      (number-of-odds -1)
      (number-of-betters 0)
      (paying-out 0)
    })
  })
})