blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
171
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
8
| license_type
stringclasses 2
values | repo_name
stringlengths 6
82
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 13
values | visit_date
timestamp[ns] | revision_date
timestamp[ns] | committer_date
timestamp[ns] | github_id
int64 1.59k
594M
⌀ | star_events_count
int64 0
77.1k
| fork_events_count
int64 0
33.7k
| gha_license_id
stringclasses 12
values | gha_event_created_at
timestamp[ns] | gha_created_at
timestamp[ns] | gha_language
stringclasses 46
values | src_encoding
stringclasses 14
values | language
stringclasses 2
values | is_vendor
bool 2
classes | is_generated
bool 1
class | length_bytes
int64 4
7.87M
| extension
stringclasses 101
values | filename
stringlengths 2
149
| content
stringlengths 4
7.87M
| has_macro_def
bool 2
classes |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
63a10d6f6a15c44333a0d6ade44468504dc276e6 | f86cc36ab66ddb8e3409a8c0ea46bd8da211dcf6 | /listings/comp.rkt | f10ce04b595fcd476cf92a1052ea2d3b20398663 | []
| no_license | bdj/thesis | 2d2d5770a65ccc9cae1e16cba917935f2eec75ec | e3a23596a4f7dce579ec8d6a0494b2325e4a890a | refs/heads/master | 2021-01-25T05:34:18.198851 | 2016-03-01T20:32:45 | 2016-03-01T20:32:45 | 8,936,139 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,977 | rkt | comp.rkt | #lang racket
(define (compile-without-optimizations filename)
(parameterize ([current-namespace (make-base-namespace)]
[compile-context-preservation-enabled #t])
(with-output-to-file (format "compiled/~a" (path-add-suffix filename ".zo"))
#:exists 'truncate
(lambda ()
(write (compile (read (open-input-file filename))))))))
(define (write-module n)
(with-output-to-file (format "m~a.rkt" n)
#:exists 'truncate
(lambda ()
(printf
"(module m~a '#%kernel
(#%require \"m~a.rkt\")
(#%provide f~a)
(define-values (f~a) (lambda (x)
(if (f~a x)
(f~a x)
(begin
(random) (random) (random) (random) (random)
(random) (random) (random) (random) (random)
)))))
"
n (add1 n) n n (add1 n) (add1 n)))))
(define (write-first-module)
(with-output-to-file "m0.rkt"
#:exists 'truncate
(lambda ()
(printf
"(module m0 '#%kernel
(#%require \"m1.rkt\")
(letrec-values ([(loop)
(values (lambda (x)
(if (= x 0)
'done
(begin
(f1 x)
(loop (sub1 x))))))])
(loop 10000000)))
"))))
(define (write-last-module n)
(with-output-to-file (format "m~a.rkt" n)
#:exists 'truncate
(lambda ()
(printf
"(module m~a '#%kernel
(#%provide f~a)
(define-values (f~a) (lambda (x)
(add1 x))))
"
n n n))))
(define num-modules
(sub1 (string->number (vector-ref (current-command-line-arguments) 0))))
(write-first-module)
(for ([i (in-range 1 num-modules)])
(write-module i))
(write-last-module num-modules)
(for ([i (in-range (add1 num-modules))])
(compile-without-optimizations (format "m~a.rkt" i)))
| false |
5b8ffd4c1b39b472f5c21520e7b3f046ff6a10fd | 184f2fed39fcea6cb136c7f2ef61ebbed6db910d | /http-easy/http-easy/private/contract.rkt | 970c023762c01737e64dc552218af59e4fcca6b7 | [
"BSD-3-Clause"
]
| permissive | DavidAlphaFox/racket-http-easy | 188b2212ff62d0e6b0d820147ce13087a07690cc | 9e126b618c346fd91e096073e59c8ec35faadc23 | refs/heads/master | 2023-06-29T23:16:16.594246 | 2021-08-02T12:35:15 | 2021-08-02T12:35:15 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 652 | rkt | contract.rkt | #lang racket/base
(require net/url
racket/contract)
(provide
method/c
headers/c
form-data/c
query-params/c
auth-procedure/c
payload-procedure/c)
(define method/c
(or/c 'delete 'head 'get 'options 'patch 'post 'put symbol?))
(define headers/c
(hash/c symbol? (or/c bytes? string?)))
(define form-data/c
(listof (cons/c symbol? (or/c false/c string?))))
(define query-params/c
(listof (cons/c symbol? (or/c false/c string?))))
(define auth-procedure/c
(-> url? headers/c query-params/c (values headers/c query-params/c)))
(define payload-procedure/c
(-> headers/c (values headers/c (or/c bytes? string? input-port?))))
| false |
00f5ca3348d0167e26ddbf7e4cf376afa9a9a44b | fc6465100ab657aa1e31af6a4ab77a3284c28ff0 | /results/all/stlc-sub-4-enum-mildly-unfair.rktd | 95ba28c13c9528d1004aedd84f258f9f519f09ca | []
| no_license | maxsnew/Redex-Enum-Paper | f5ba64a34904beb6ed9be39ff9a5e1e5413c059b | d77ec860d138cb023628cc41f532dd4eb142f15b | refs/heads/master | 2020-05-21T20:07:31.382540 | 2017-09-04T14:42:13 | 2017-09-04T14:42:13 | 17,602,325 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 271 | rktd | stlc-sub-4-enum-mildly-unfair.rktd | (start 2015-06-16T21:59:46 (#:model "stlc-sub-4" #:type enum-mildly-unfair))
(finished 2015-06-17T21:59:12 (#:model "stlc-sub-4" #:type enum-mildly-unfair #:time-ms 86400009 #:attempts 6771516 #:num-counterexamples 0 #:rate-terms/s 78.3740196138174 #:attempts/cexp N/A))
| false |
3a021b534ac8d7187ad4ec3f5c7a642331cc61ed | aac00fa20ca35abc9557b5ec16b021c8c333992a | /expressive/matrix.rkt | f09d6315c77491e068ff81d1cabde1660ba292eb | []
| no_license | spdegabrielle/artifact2020 | c80ddced4c6be4bbe159c5ac42539b20f79e82c6 | 1863e9b58a09232bc85ba9fb6b1832c974559ad9 | refs/heads/master | 2022-12-03T12:48:55.930122 | 2020-08-09T05:21:25 | 2020-08-19T03:06:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 4,992 | rkt | matrix.rkt | #lang editor editor/lang
(require editor/base
math/matrix
racket/class
data/gvector
(for-syntax racket/base
racket/syntax)
(for-editor racket/gui/base
racket/math
racket/match
data/gvector))
(define-interactive-syntax matrix-state$ base$
#:interfaces (receiver<$>)
(super-new)
(define-state width 0
#:getter #t
#:setter (λ (new-width)
(set! width new-width)
(resize-matrix)))
(define-state height 0
#:getter #t
#:setter (λ (new-height)
(set! height new-height)
(resize-matrix)))
(define-state values (make-gvector)
#:getter #t)
(define/private (resize-matrix)
(define new-length (* width height))
(define old-length (gvector-count values))
(if (new-length . > . old-length)
(for ([i (in-range (- new-length old-length))])
(gvector-add! values 0))
(for ([i (in-range (- old-length new-length))])
(gvector-remove-last! values))))
(define/public (set-cell! row col val)
(gvector-set! values (+ (* row width) col) val))
(define/public (on-receive sender event)
(cond
[(is-a? event control-event%)
(when (eq? (send event get-event-type) 'text-field)
(set-cell! (send sender get-row)
(send sender get-col)
(string->number (send sender get-text))))])))
(define-interactive-syntax cell$ field$
(init [(ir row) 0]
[(ic col) 0])
(define-state row ir
#:getter #t
#:persistence #f)
(define-state col ic
#:getter #t
#:persistence #f)
(super-new))
(define-interactive-syntax matrix-body$ vertical-block$
(inherit count
remove-child
in-children
get-parent)
(super-new)
(define/public (fill-cells cells width)
(for ([row (in-children)]
[i (in-naturals)])
(for ([cell (send row in-children)]
[j (in-naturals)])
(send cell set-text!
(number->string (gvector-ref cells (+ (* i width) j)))))))
;; Change the dimentions of the matrix to the new width/height.
(define/public (change-dimensions width height)
(define height-diff (abs (- height (count))))
;; First grow rows
(cond
[(height . < . (count))
(for ([_ (in-range height-diff)])
(remove-child))]
[(height . > . (count))
(for ([_ (in-range height-diff)])
(new horizontal-block$ [parent this]))])
;; Then collumns in thos rows
(for ([row (in-children)]
[row-index (in-naturals)])
(define existing-width (send row count))
(define width-diff (abs (- width existing-width)))
(cond
[(width . < . existing-width)
(for ([_ (in-range width-diff)])
(send row remove-child))]
[(width . > . existing-width)
(for ([_ (in-range width-diff)]
[col-index (in-naturals existing-width)])
(new cell$ [parent row]
[row row-index]
[col col-index]
[text "0"]
[callback (send this get-parent)]))]))))
(define-interactive-syntax matrix$ (signaler$$ vertical-block$)
#:interfaces (receiver<$>)
(super-new)
(define-state state (new matrix-state$)
#:getter #t)
(define-elaborator this
#'(let ()
(define state (send this get-state))
(vector->matrix (send state get-height)
(send state get-width)
(gvector->vector (send state get-values)))))
(define/public (on-receive sender message)
(send state on-receive sender message))
(define w-row (new horizontal-block$ [parent this]))
(define h-row (new horizontal-block$ [parent this]))
(new label$ [parent w-row] [text "Width: "])
(define/public (w-str-callback this event)
(define w (string->number (send this get-text)))
(when (and w (natural? w))
(send state set-width! w)
(send the-matrix change-dimensions
(send state get-width)
(send state get-height))))
(define w-str (new field$ [parent w-row]
[text (number->string (send state get-width))]
[callback (list this 'w-str-callback)]))
(new label$ [parent h-row] [text "Height: "])
(define/public (h-str-callback this event)
(define h (string->number (send this get-text)))
(when (and h (natural? h))
(send state set-height! h)
(send the-matrix change-dimensions
(send state get-width)
(send state get-height))))
(define h-str (new field$ [parent h-row]
[text (number->string (send state get-height))]
[callback (list this 'h-str-callback)]))
(define the-matrix (new matrix-body$ [parent this])))
(begin-for-interactive-syntax
(module+ test
(require editor/test)
(test-window (new matrix$))))
| false |
bff1a9abc0745dfed3ab6c9d2e703ae100653672 | 27451bfaa208d6c2b9f3da3c87511d65b2ef5476 | /parseralt.rkt | b33717b3f408a92e15502dffaa91fb4c4c8dc961 | []
| no_license | gillnana/tigerracket | 15ae1201d0d3b742b344f6f943bfb133924dde22 | abbedc7bf6d070d604efe8cd89bee6d0cdbe7e99 | refs/heads/master | 2016-09-15T20:43:54.572658 | 2011-05-17T05:37:04 | 2011-05-17T05:37:04 | 1,339,212 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 29,341 | rkt | parseralt.rkt | #lang racket
(require parser-tools/yacc)
(require parser-tools/lex)
(require (prefix-in : parser-tools/lex-sre))
(require test-engine/racket-tests)
(provide (all-defined-out))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; Lexer ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-tokens tiger-tokens
(id
int
string
; comment ; this should not be a token; comments are like whitespace
))
(define-empty-tokens tiger-empty-tokens
(type
array
var
function
if
then
else
while
do
for
to
let
in
end
of
break
nil
unit
plus
minus
times
divide
equals
not-equals
less-than
greater-than
less-or-equal
greater-or-equal
and
or
open-paren
close-paren
open-brace
close-brace
open-bracket
close-bracket
dot
comma
semicolon
colon
arrow
assign
invalid ; for lexical errors
eof ; special end of file token
))
(define lex
(lexer
[whitespace (lex input-port)]
[(eof) (token-eof)]
;["EOF" (token-eof)]
; keywords
["type" (token-type)]
["array" (token-array)]
["var" (token-var)]
["function" (token-function)]
["if" (token-if)]
["then" (token-then)]
["else" (token-else)]
["while" (token-while)]
["do" (token-do)]
["for" (token-for)]
["to" (token-to)]
["let" (token-let)]
["in" (token-in)]
["end" (token-end)]
["of" (token-of)]
["break" (token-break)]
["nil" (token-nil)]
["unit" (token-unit)]
; reserved words (like keywords, but no meaning)
["and" (token-invalid)]
["or" (token-invalid)]
["not" (token-invalid)]
["goto" (token-invalid)]
; arithmetic
["+" (token-plus)]
["-" (token-minus)]
["*" (token-times)]
["/" (token-divide)]
; comparators
["=" (token-equals)]
["<>" (token-not-equals)]
["<" (token-less-than)]
[">" (token-greater-than)]
["<=" (token-less-or-equal)]
[">=" (token-greater-or-equal)]
; logical operators
; TODO: what about NOT?
["&" (token-and)]
["|" (token-or)]
; parens and things
["(" (token-open-paren)]
[")" (token-close-paren)]
["{" (token-open-brace)]
["}" (token-close-brace)]
["[" (token-open-bracket)]
["]" (token-close-bracket)]
; other punctuation
["." (token-dot)]
["," (token-comma)]
[";" (token-semicolon)]
[":" (token-colon)]
["->" (token-arrow)]
; assignment
[":=" (token-assign)]
;TODO fix 4a
; identifiers
[(concatenation alphabetic
(repetition 0 +inf.0
(union alphabetic
(char-range #\0 #\9)
"_")))
(token-id (string->symbol lexeme))]
; numbers (integers)
[(repetition 1 +inf.0 (char-range #\0 #\9))
(token-int (string->number lexeme))]
; strings
["\"" (token-string (string-lex input-port))]
; comments are the same as whitespace
[(:: "/*" (complement (:: any-string "*/" any-string)) "*/")
(lex input-port)]
))
; call this after eating the open double-quote character
; it will eat up to and including the close double-quote
; and return a list of string to concatenate together
(define (string-lex input-port)
(define (prepend str)
(string-append str (string-lex input-port)))
((lexer
[(repetition 1 +inf.0 (union alphabetic
whitespace ; excludes newlines
(intersection punctuation
(complement "\\")
(complement "\""))
))
(prepend lexeme)]
["\\\\" (prepend "\\")]
["\\n" (prepend "\n")]
["\\t" (prepend "\t")]
["\\\"" (prepend "\"")]
["\"" ""]
[(eof) (error "eof in string")])
input-port))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; Parser ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; literals
; value is a scheme integer
(struct int-literal (value) #:transparent)
; value is a scheme string
(struct string-literal (value) #:transparent)
(struct nil () #:transparent)
; array and struct creation
; type-id is a type-id struct
; initval is an expression
(struct array-creation (type-id size initval) #:transparent)
; type-id is a type-id struct
; fieldvals is a list of fieldval
(struct record-creation (type-id fieldvals) #:transparent)
; name is a symbol
; val is an expression
(struct fieldval (name val) #:transparent)
; lvalues' intermediate representation
; this is used within the parser to parse lvalues right-recursively
; it is never returned by the parser at the top level
(struct lvalue-record-access (id) #:transparent)
(struct lvalue-array-access (index) #:transparent)
; lvalues - true representation
; id is always a variable
; an id is not an expression
; an lvalue of an id and no suffixes is, however
; see struct lvalue
(struct id (name) #:transparent)
; rec-id is an lvalue
(struct record-access (rec-id field-id) #:transparent)
; id is an lvalue
(struct array-access (id index) #:transparent)
; declarations
(struct tydec (type-id ty) #:transparent) ; type declaration
(struct vardec (id type-id val) #:transparent) ; type-id can be #f
(struct fundec (id tyfields type-id body) #:transparent) ; type-id can be #f
(struct funcall (fun-id args) #:transparent)
; types
(struct type-id (name) #:transparent)
(struct function-type (dom rng) #:transparent) ; domain and range
(struct record-of (tyfields) #:transparent) ; record type contains list of tyfield
(struct tyfield (id type-id) #:transparent)
(struct array-of (type) #:transparent) ; array type
; assignment
(struct assignment (lvalue val) #:transparent)
; program structure
(struct if-statement (cond then else) #:transparent) ; else is optional
(struct while-statement (cond body) #:transparent)
(struct for-statement (var start end body) #:transparent)
;(struct sequence (expseq) #:transparent)
(struct expseq (exps) #:transparent)
; body is an expression
(struct let-vars (bindings body) #:transparent)
(struct let-types (bindings body) #:transparent)
(struct let-funs (bindings body) #:transparent)
(struct op (op) #:transparent)
(struct binary-op (op arg1 arg2) #:transparent)
(struct unary-op (op arg1) #:transparent)
(struct break () #:transparent)
(define parse
(parser
(tokens tiger-tokens tiger-empty-tokens)
(grammar
(decs [(dec decs) (cons $1 $2)]
[() empty])
(dec [(tydec) $1]
[(vardec) $1]
[(fundec) $1])
(tydec [(type id equals ty) (tydec $2 $4)])
(ty [(id) (type-id $1)]
;[(unit) (type-id 'unit)] ;TODO how to handle unit?
[(open-brace tyfields close-brace) (record-of $2)]
[(array of id) (array-of (type-id $3))]
[(ty arrow ty) (function-type (list $1) $3)]
[(open-paren tylist close-paren arrow ty) (function-type $2 $5)]
)
(tylist [() empty]
[(ty) (list $1)]
[(ty comma tylist) (cons $1 $3)])
(tyfields [() empty]
[(id colon id) (cons (tyfield $1 (type-id $3)) empty)]
[(id colon id comma tyfields) (cons (tyfield $1 (type-id $3)) $5)])
(vardec [(var id assign exp) (vardec $2 #f $4)]
[(var id colon id assign exp) (vardec $2 $4 $6)])
(fundec [(function id open-paren tyfields close-paren equals exp) (fundec $2 $4 #f $7)]
[(function id open-paren tyfields close-paren colon id equals exp) (fundec $2 $4 $7 $9)])
(exp [(literal) $1]
[(lvalue) $1]
[(funcall) $1]
[(arithmetic) $1]
[(structures) $1]
[(assignment) $1]
[(control) $1]
)
(lvalue [(id lvalue-rest)
(foldl (lambda (lval-suf sub-lval)
; transform-lvalue into left recursive representation
; lval-suf is the first suffix in the suffix list
; sub-lval is the new lvalue constructed so far
(match lval-suf
[(lvalue-record-access field-name) (record-access sub-lval field-name)]
[(lvalue-array-access index) (array-access sub-lval index)]))
(id $1)
$2)])
(lvalue-rest [() empty]
[(dot id lvalue-rest) (cons (lvalue-record-access $2) $3)]
[(open-bracket exp close-bracket lvalue-rest) (cons (lvalue-array-access $2) $4)])
(literal [(int) (int-literal $1)]
[(string) (string-literal $1)]
[(nil) (nil)])
(funcall [(exp open-paren funcall-args close-paren) (funcall $1 $3)])
(funcall-args [() empty]
[(exp) (cons $1 empty)]
[(exp comma funcall-args) (cons $1 $3)])
(arithmetic [(exp plus exp) (binary-op (op '+) $1 $3)]
[(exp minus exp) #;(prec plus) (binary-op (op '-) $1 $3)]
[(exp times exp) (binary-op (op '*) $1 $3)]
[(exp divide exp) (binary-op (op '/) $1 $3)]
[(exp equals exp) (binary-op (op '=) $1 $3)]
[(exp not-equals exp) (binary-op (op '<>) $1 $3)]
[(exp less-than exp) (binary-op (op '<) $1 $3)]
[(exp less-or-equal exp) (binary-op (op '<=) $1 $3)]
[(exp greater-than exp) (binary-op (op '>) $1 $3)]
[(exp greater-or-equal exp) (binary-op (op '>=) $1 $3)]
[(exp and exp) (binary-op (op '&) $1 $3)]
[(exp or exp) (binary-op (op 'or) $1 $3)]
[(minus exp) (prec open-paren) (unary-op (op '-) $2)]
)
(structures [(record-creation) $1]
[(array-creation) $1])
(record-creation [(id open-brace record-creation-args close-brace) (record-creation (type-id $1) $3)])
(record-creation-args [() empty]
[(id equals exp) (cons (fieldval $1 $3) empty)]
[(id equals exp comma record-creation-args) (cons (fieldval $1 $3) $5)])
(array-creation [(id open-bracket exp close-bracket of exp) (array-creation (type-id $1) $3 $6)])
(assignment [(lvalue assign exp) (assignment $1 $3)])
;
(control [(if-nonterminal) $1]
[(while-nonterminal) $1]
[(for-nonterminal) $1]
[(break) (break)]
[(let-nonterminal) $1]
[(sequencing) $1])
(if-nonterminal [(if exp then exp else exp) (if-statement $2 $4 $6)]
[(if exp then exp) (if-statement $2 $4 (expseq empty))]
)
(while-nonterminal [(while exp do exp) (while-statement $2 $4)])
(let-nonterminal [(let decs in expseq end)
; transform-let into 3 different types of lets
(foldr (lambda (dec new-let)
(cond
[(and (tydec? dec)
(let-types? new-let)) (let-types (cons dec (let-types-bindings new-let))
(let-types-body new-let))]
[(and (fundec? dec)
(let-funs? new-let)) (let-funs (cons dec (let-funs-bindings new-let))
(let-funs-body new-let))]
[(and (vardec? dec)
(let-vars? new-let)) (let-vars (cons dec (let-vars-bindings new-let))
(let-vars-body new-let))]
[(tydec? dec) (let-types (list dec)
new-let)]
[(fundec? dec) (let-funs (list dec)
new-let)]
[(vardec? dec) (let-vars (list dec)
new-let)]))
(expseq $4)
$2)
; (let-statement $2 (expseq $4))
])
(for-nonterminal [(for id assign exp to exp do exp) (for-statement $2 $4 $6 $8)])
(expseq [() empty]
[(exp) (cons $1 empty)]
[(exp semicolon expseq) (cons $1 $3)]
; TODO: LISTEN TO ROAN MORE OFTEN
)
(sequencing [(open-paren expseq close-paren) (expseq $2)])
)
; lower on this list means binds tighter
(precs (nonassoc do)
(nonassoc assign)
(right then else)
(nonassoc of)
(right arrow)
(left or)
(left and)
(nonassoc equals not-equals greater-or-equal less-or-equal greater-than less-than)
(left plus minus)
(left divide times)
#;(left minus)
; parens correspond to function application
(nonassoc open-paren open-bracket close-paren close-bracket open-brace close-brace)
; (nonassoc comma semicolon colon dot)
; ()
; (nonassoc id) ;this removed 1 shift-reduce conflict
; (nonassoc var type array function break if while for to let in end)
)
(start exp)
(end eof)
(error (λ (valid? token value)
(error
(format "parse error at ~a: with value:~a was token valid?:~a"
token
value
valid?))))
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; Canonicalization ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (symbol<=? sym1 sym2)
(string<=? (symbol->string sym1)
(symbol->string sym2)))
(struct record-index (id offset-list) #:transparent)
(struct field-offset (id num) #:transparent)
(struct record-access-offset (rec-id field-id offset))
(define (canonicalize ast r-indx)
; TODO make sure that fields are specified in the same order as declared for record creation
; do this by alphabetizing the field order at canonicalization
; note type checking must follow canonicalization in this case
(match ast
[(for-statement index start end body)
(expseq
(list
(assignment (id index) start)
(while-statement (binary-op (op '<=) index end)
(expseq
(list
(canonicalize body r-indx)
(binary-op (op '+) index (int-literal 1)))))))]
[(while-statement cond body) (while-statement (canonicalize cond r-indx) (canonicalize body r-indx))]
[(if-statement c t e) (if-statement (canonicalize c r-indx)
(canonicalize t r-indx)
(canonicalize e r-indx))]
[(binary-op (op '&) a b)
(if-statement (canonicalize a r-indx)
(if-statement (canonicalize b r-indx) (int-literal 1) (int-literal 0))
(int-literal 0))]
[(binary-op (op 'or) a b)
(if-statement (canonicalize a r-indx)
(int-literal 1)
(if-statement (canonicalize b r-indx) (int-literal 1) (int-literal 0)))]
[(binary-op other a b) (binary-op other (canonicalize a r-indx) (canonicalize b r-indx))]
[(unary-op op a) (unary-op op (canonicalize a r-indx))]
[(expseq seq) (expseq (map (λ (exp) (canonicalize exp r-indx)) seq))]
[(array-access id index) (array-access (canonicalize id r-indx) (canonicalize index r-indx))]
[(funcall fun-id args) (funcall fun-id (map (λ (arg) (canonicalize arg r-indx)) args))]
[(record-creation type-id fieldvals) (record-creation type-id
(sort (map
(match-lambda
[(fieldval name val)
(fieldval name (canonicalize val r-indx))])
fieldvals)
(match-lambda*
[(list (fieldval name1 _)
(fieldval name2 _))
(symbol<=? name1 name2)])))]
[(array-creation type-id size initval) (array-creation type-id (canonicalize size r-indx) (canonicalize initval r-indx))]
[(assignment lvalue val) (assignment (canonicalize lvalue r-indx) (canonicalize val r-indx))]
[(vardec id type-id val) (vardec id type-id (canonicalize val r-indx))]
[(fundec id tyfields type-id body) (fundec id tyfields type-id (canonicalize body r-indx))]
[(let-vars bindings body) (let-vars (map (λ (binding) (canonicalize binding r-indx)) bindings) (canonicalize body r-indx))]
[(let-funs bindings body) (let-funs (map (λ (binding) (canonicalize binding r-indx)) bindings) (canonicalize body r-indx))]
[(let-types bindings body)
(local [(define sorted-bindings (map (match-lambda
[(tydec type-id (record-of tyfields))
(tydec type-id (record-of (sort tyfields
(match-lambda*
[(list (tyfield id1 _)
(tyfield id2 _))
(symbol<=? id1 id2)]))))]
[other-tydec other-tydec])
bindings))
(define (accumulate-record-indices sorted-binding record-index-acc)
(match sorted-binding
[(tydec id (record-of tyfields))
(cons (record-index id (map (λ (tf num)
(field-offset (tyfield-id tf) num))
tyfields
(build-list (length tyfields) values))) record-index-acc)]))]
(let-types sorted-bindings (canonicalize body (foldl accumulate-record-indices
r-indx
(filter (match-lambda
[(tydec type-id (record-of tyfields)) #t]
[other-tydec #f])
sorted-bindings)))))]
[(int-literal val) (int-literal val)]
[(string-literal val) (string-literal val)]
[(nil) (nil)]
[(id a) (id a)]
[(break) (break)]
; TODO: error here or just false in record-access-offset-struct
; related question: do we do canonicalization before or after typechecking?
[(record-access rec-id field-id)
(let [(offset (ormap (match-lambda
[(record-index rec-type offset-list)
(and (equal? rec-type rec-id)
(ormap (match-lambda
[(field-offset fi num)
(and (equal? fi field-id)
num)])
offset-list))])
r-indx))]
(when (not offset)
(displayln r-indx)
(error (format "unknown field ~a of record type ~a" field-id rec-id)))
(record-access-offset rec-id field-id offset))]
[(tydec type-id ty) (tydec type-id ty)]
[else else]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;; Helpers and tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (run)
(parse (λ () (lex (current-input-port)))))
(define (parse-string str)
(let [(port (open-input-string str))]
(parse (λ () (lex port)))))
(define (lex-string str)
(let [(port (open-input-string str))]
(λ () (lex port))))
(define (parse-file file)
(let [(port (open-input-file file))]
(parse (λ () (lex port)))))
(check-expect (parse-string "4") (int-literal 4))
(check-expect (parse-string "\"zoomba\"") (string-literal "zoomba"))
(check-expect (parse-string "\"he said \\\"hi\\\", right?\"") (string-literal "he said \"hi\", right?"))
(check-expect (parse-string "nil") (nil))
(check-expect (parse-string "some_identifier") (id 'some_identifier))
;;dangling else testing
(check-expect (parse-string "if 4 then 4")
(if-statement (int-literal 4) (int-literal 4) (expseq empty)))
(check-expect (parse-string "if 5 then 5 else 5")
(if-statement (int-literal 5) (int-literal 5) (int-literal 5)))
(check-expect (parse-string "if if 1 then 1 then if 2 then 2 else if 3 then 3")
(if-statement (if-statement (int-literal 1) (int-literal 1) (expseq empty)) (if-statement (int-literal 2) (int-literal 2) (if-statement (int-literal 3) (int-literal 3) (expseq empty))) (expseq empty) ))
(check-expect (parse-string "if 4 then if 5 then 5 else 5")
(if-statement (int-literal 4) (if-statement (int-literal 5) (int-literal 5) (int-literal 5)) (expseq empty)))
(check-expect (parse-string "if 4 then (if 5 then 5) else 4")
(if-statement (int-literal 4) (expseq (list (if-statement (int-literal 5) (int-literal 5) (expseq empty)))) (int-literal 4)))
;dangling do testing
(check-expect (parse-string "while 4 do 4")
(while-statement (int-literal 4) (int-literal 4)))
(check-expect (parse-string "while 5 do while 6 do 6")
(while-statement (int-literal 5) (while-statement (int-literal 6) (int-literal 6))))
(check-expect (parse-string "while 5 do for pig := 7 to 7 do 7")
(while-statement (int-literal 5) (for-statement 'pig (int-literal 7) (int-literal 7) (int-literal 7))))
(check-expect (parse-string "for pig := 8 to 8 do while 6 do 6")
(for-statement 'pig (int-literal 8) (int-literal 8) (while-statement (int-literal 6) (int-literal 6))))
(check-expect (parse-string "for apple := 10 to 10 do for mike := 20 to 20 do 20")
(for-statement 'apple (int-literal 10) (int-literal 10) (for-statement 'mike (int-literal 20) (int-literal 20) (int-literal 20))))
(check-expect (parse-string "for apple := 36 to for mike := 11 to 11 do 11 do 36")
(for-statement 'apple (int-literal 36) (for-statement 'mike (int-literal 11) (int-literal 11) (int-literal 11)) (int-literal 36)))
(check-expect (parse-string "a.b.c.d.zoomba[pizza].lorg[a.b]")
(array-access
(record-access (array-access (record-access (record-access (record-access (record-access (id 'a) 'b) 'c) 'd) 'zoomba) (id 'pizza)) 'lorg)
(record-access (id 'a) 'b)))
(check-expect (parse-string "a.b.c.d.zoomba[pizza].lorg[a.b] := 7")
(assignment
(array-access
(record-access (array-access (record-access (record-access (record-access (record-access (id 'a) 'b) 'c) 'd) 'zoomba) (id 'pizza)) 'lorg)
(record-access (id 'a) 'b))
(int-literal 7)))
;lvalue testing including array accesses and declarations
(check-expect (parse-string "drugs.f")
(record-access (id 'drugs) 'f))
(check-expect (parse-string "bears[philip] of 7")
(array-creation (type-id 'bears) (id 'philip) (int-literal 7)))
(check-expect (parse-string "int[philip] of 7")
(array-creation (type-id 'int) (id 'philip) (int-literal 7)))
(check-expect (parse-string "a[b]")
(array-access (id 'a) (id 'b)))
;; let in sequence
(check-expect (parse-string "let in 1 end") (expseq (list (int-literal 1))))
(check-expect (parse-string "let in 1; 2 end") (expseq (list (int-literal 1) (int-literal 2))))
(check-expect (parse-string "let in (1; 2) end") (expseq (list (expseq (list (int-literal 1) (int-literal 2))))))
;precedence testing
(check-expect (parse-string "4/5*6")
(binary-op (op '*) (binary-op (op '/) (int-literal 4) (int-literal 5)) (int-literal 6)))
(check-expect (parse-string "4*5/6")
(binary-op (op '/) (binary-op (op '*) (int-literal 4) (int-literal 5)) (int-literal 6)))
(check-expect (parse-string "1+2*3")
(binary-op (op '+) (int-literal 1) (binary-op (op '*) (int-literal 2) (int-literal 3))))
(check-expect (parse-string "1*4+5")
(binary-op (op '+) (binary-op (op '*) (int-literal 1) (int-literal 4)) (int-literal 5)))
;type declaration tests
(check-expect (parse-string "let type a = int in end")
(let-types (list (tydec 'a (type-id 'int))) (expseq empty)))
(check-expect (parse-string "let type b = array of charlie in end")
(let-types (list (tydec 'b (array-of (type-id 'charlie)))) (expseq empty)))
(check-expect (parse-string "let type c = {} in end")
(let-types (list (tydec 'c (record-of empty))) (expseq empty)))
(check-expect (parse-string "let type d = { beer : int } in end")
(let-types (list (tydec 'd (record-of (list (tyfield 'beer (type-id 'int)))))) (expseq empty)))
(check-expect (parse-string "let type e = { chocolate : int, mufflepuff : stormclouds, wozzar : string} in end")
(let-types (list (tydec 'e (record-of (list (tyfield 'chocolate (type-id 'int))
(tyfield 'mufflepuff (type-id 'stormclouds))
(tyfield 'wozzar (type-id 'string))))))
(expseq empty)))
; breaking up let-statement tests
(check-expect (parse-string "let type a = horse type b = radish in end")
(let-types (list (tydec 'a (type-id 'horse))
(tydec 'b (type-id 'radish)))
(expseq empty)))
(check-expect (parse-string "let var x := 12 var y := 47 in end")
(let-vars (list (vardec 'x false (int-literal 12))
(vardec 'y false (int-literal 47)))
(expseq empty)))
(check-expect (parse-string "let function f() : int = 1 function g() : string = \"zebra\" in end")
(let-funs (list (fundec 'f empty 'int (int-literal 1))
(fundec 'g empty 'string (string-literal "zebra")))
(expseq empty)))
; function types
(check-expect (parse-string "let type f = {} -> {} in end")
(let-types (list
(tydec 'f (function-type (list (record-of empty))
(record-of empty))))
(expseq empty)))
(check-expect (parse-string "let type f = int -> int -> int in end")
(let-types (list
(tydec 'f (function-type (list (type-id 'int))
(function-type (list (type-id 'int))
(type-id 'int)))))
(expseq empty)))
(check-expect (parse-string "let type f = ( int, int ) -> int in end")
(let-types (list (tydec 'f (function-type (list (type-id 'int) (type-id 'int)) (type-id 'int)))) (expseq empty)))
(check-expect (parse-string "let type f = ( int -> int ) -> int in end")
(let-types (list
(tydec 'f (function-type (list (function-type (list (type-id 'int)) (type-id 'int)))
(type-id 'int))))
(expseq empty)))
(check-expect (parse-string "7 /*****asdf***/ + /**omgwtfbbg*/ 2")
(binary-op (op '+) (int-literal 7) (int-literal 2)))
; file io
(check-expect (parse-file "./tests/four.tig")
(int-literal 4))
;; just check that it parses, don't examine the tree
(check-expect (begin (parse-file "./tests/queens.tig") 'great)
'great)
;; canonicalization tests
(check-expect (begin (canonicalize (parse-file "./tests/queens.tig")) (call/cc (λ (k) {k (k "pizza")}))) "pizza")
;(test) | false |
2d69484d37b564e449601dc9a8cc5bfa49192fcb | bdc2f1aeef43e01f0f308121a97813549a00275a | /remarkable/remarkable.rkt | 8aff9b7013157de6f4e4875998e08e5242f6d29d | []
| no_license | lihebi/scratch | a8362a9af5663142c3976fdc0866f3c93ad3b79c | 4fe0183ce1c73b00d48dc8ed5de6965b36ae7966 | refs/heads/master | 2021-01-11T06:53:01.402194 | 2019-11-21T03:04:14 | 2019-11-21T03:04:14 | 72,402,230 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 8,464 | rkt | remarkable.rkt | #lang racket
(require json)
(require racket/path)
(require pdf-read)
(require pict)
(require file/convertible)
(define (download-meta! metadir)
;; scp all metadata from 10.11.99.1
(when (not (directory-exists? metadir))
(make-directory metadir))
(let ([scp-cmd (~a "scp -r [email protected]:~/.local/share/remarkable/xochitl/*.metadata "
metadir)])
(system scp-cmd)))
(define (show-contents metadir)
;; show uuid, filename pairs
(for/list ([f (in-directory metadir)])
(let* ([uuid (path->string
(path-replace-extension
(file-name-from-path f) ""))]
[meta (string->jsexpr (file->string f))]
[filename (meta->filename meta)])
(list uuid filename))))
(define (meta->filename meta)
(hash-ref meta 'visibleName))
;; - get UUID.pdf
;; - get UUID.lines
(define (download-uuid uuid)
(when (directory-exists? uuid)
(delete-directory/files uuid))
(make-directory uuid)
(let ([scp-cmd (~a "scp [email protected]:~/.local/share/remarkable/xochitl/"
uuid "* " uuid)])
(system scp-cmd)))
(define (get-pdfunite-cmds pdf-dir annotate-file)
(letrec ([pdf-lst (sort (for/list ([p (in-directory pdf-dir)])
(path->string p))
(lambda (p1 p2)
(let ([get-id (λ (p)
(string->number
(second
(regexp-match #px"([0-9]*)\\.pdf" p))))])
(< (get-id p1)
(get-id p2)))))]
[func (λ (lst out)
(if (<= (length lst) 100)
(list (~a "pdfunite " (string-join lst " ") " " out))
(let ([part1 (~a out "-part1.pdf")]
[part2 (~a out "-part2.pdf")])
(append (func (take lst 100) part1)
(func (drop lst 100) part2)
(list (~a "pdfunite " part1 " " part2 " " out))))))])
(func pdf-lst (path->string annotate-file))))
(module+ test
(for ([cmd (get-pdfunite-cmds "2a082b3c-9997-4b08-a7ae-9c3556ea5b92/pdf"
(string->path "tmp/annotate.pdf"))])
(system cmd))
(first (get-pdfunite-cmds "2a082b3c-9997-4b08-a7ae-9c3556ea5b92/pdf"
(string->path "tmp/annotate.pdf")))
(sort (for/list ([p (in-directory "2a082b3c-9997-4b08-a7ae-9c3556ea5b92/pdf")])
(path->string p))
(lambda (p1 p2)
(let ([get-id (λ (p)
(string->number
(second
(regexp-match #px"([0-9]*).pdf" p))))])
(< (get-id p1)
(get-id p2)))))
(take (sort (directory-list "2a082b3c-9997-4b08-a7ae-9c3556ea5b92/pdf")
(lambda (p1 p2)
(let ([get-id (λ (p)
(string->number
(second
(regexp-match #px"([0-9]*).pdf" (path->string p)))))])
(< (get-id p1)
(get-id p2))))) 50)
)
(define (save-file p filename)
(let ([out (open-output-file filename
#:mode 'binary
#:exists 'replace)])
(write-bytes (convert p 'pdf-bytes)
out)
(close-output-port out)))
(define (annotate uuid)
(let ([svg-dir (build-path uuid "svg")]
[pdf-dir (build-path uuid "pdf")]
[final-pdf-dir (build-path uuid "final-pdf")]
[original-pdf (build-path uuid (~a uuid ".pdf"))]
[lines-file (build-path uuid (~a uuid ".lines"))]
[annotate-file (build-path uuid "annotate.pdf")]
[final-file (build-path uuid "final.pdf")])
(when (directory-exists? svg-dir)
(delete-directory/files svg-dir))
(make-directory svg-dir)
(when (directory-exists? pdf-dir)
(delete-directory/files pdf-dir))
(make-directory pdf-dir)
(when (directory-exists? final-pdf-dir)
(delete-directory/files final-pdf-dir))
(make-directory final-pdf-dir)
;; - rM2svg --coloured_annotations -i UUID.lines -o UUID
(displayln "rM2svg")
(let ([lines->svg-cmd (~a "rM2svg -i " (path->string lines-file)
" -o " (path->string (build-path svg-dir uuid)))])
(system lines->svg-cmd))
;; - optional: transform
;; - for *.svg do rsvg-convert -f pdf -o XXX.pdf XXX.svg
(displayln "rsvg-convert")
(for ([p (directory-list svg-dir)])
(let ([cmd
(~a "rsvg-convert -f pdf -o "
(path->string (build-path pdf-dir (path-replace-extension p ".pdf")))
" " (path->string (build-path svg-dir p)))])
(system cmd)))
(displayln "pdfunite")
;; - pdfunite *.pdf UUID_annot.pdf
(for ([pdfunite-cmd (get-pdfunite-cmds pdf-dir annotate-file)])
(system pdfunite-cmd))
;; - pdftk UUID.pdf multistamp UUID_annot.pdf output final.pdf
;; (displayln "pdftk")
#;
(let ([pdftk-cmd (~a "pdftk "
(path->string original-pdf)
" multistamp "
(path->string annotate-file)
" output " (path->string final-file))])
(system pdftk-cmd))
(displayln "stamp annotation")
(stamp-annotate original-pdf annotate-file final-pdf-dir)
;; unite
(displayln "final unite")
(for ([pdfunite-cmd (get-pdfunite-cmds final-pdf-dir final-file)])
(system pdfunite-cmd))))
(define (stamp-annotate original-file annotate-file outdir)
(let ([ct (min (pdf-count-pages original-file)
(pdf-count-pages annotate-file))])
(for ([i (range ct)])
(display ".")
(flush-output)
(let ([original-pdf (page->pict (pdf-page original-file i))]
[annotate-pdf (page->pict (pdf-page annotate-file i))]
[outfile (build-path outdir (~a i ".pdf"))])
(let ([pict (ct-superimpose original-pdf
(scale-to-fit annotate-pdf original-pdf #:mode 'preserve/max))])
(save-file pict (path->string outfile)))))))
(module+ test
(download-meta! "output")
(show-contents "output")
(define uuid "0d618cf2-81fe-479a-bce7-908281a78a3b")
(download-uuid uuid)
(annotate uuid)
(download-uuid "0f01c9ed-1f52-437d-9606-8608efec6c02")
(annotate "0f01c9ed-1f52-437d-9606-8608efec6c02")
(download-uuid "f8d4f0a4-2051-4045-8f2d-7785657a9c3c")
(download-uuid "2a082b3c-9997-4b08-a7ae-9c3556ea5b92")
(annotate "2a082b3c-9997-4b08-a7ae-9c3556ea5b92")
(page-size (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/annotate.pdf" 1))
(page-size (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/pdf/0d618cf2-81fe-479a-bce7-908281a78a3b_05.pdf" 0))
(page-size (pdf-page "2a082b3c-9997-4b08-a7ae-9c3556ea5b92/2a082b3c-9997-4b08-a7ae-9c3556ea5b92.pdf" 0))
(define annot-pict (page->pict (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/annotate.pdf" 7)))
(define p5-pict (page->pict (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/0d618cf2-81fe-479a-bce7-908281a78a3b.pdf" 7)))
;; (define annot-pict (page->pict (pdf-page "tmp/annotate.pdf" 7)))
(define original-pict (page->pict (pdf-page "tmp/original.pdf" 7)))
(page-size (pdf-page "tmp/annotate.pdf" 7))
(page-size (pdf-page "tmp/original.pdf" 7))
(save-file (ct-superimpose annot-pict original-pict)
"test.pdf")
(page-size (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/0d618cf2-81fe-479a-bce7-908281a78a3b.pdf" 0))
(page-size (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/annotate.pdf" 0))
;; (/ 1053.0 612)
;; (/ 1404 792.0)
(pict-width annot-pict)
(pict-height annot-pict)
(pict-width p5-pict)
(pict-height p5-pict)
(ct-superimpose p5-pict
(scale-to-fit annot-pict p5-pict #:mode 'preserve/max))
(page-size (pdf-page "0d618cf2-81fe-479a-bce7-908281a78a3b/0d618cf2-81fe-479a-bce7-908281a78a3b.pdf" 1))
(/ 1404 612)
(/ 1872 792)
(define meta (string->jsexpr
(file->string "output/fc991453-9476-404d-ae66-ed68bcb52dc2.metadata")))
(path-replace-extension
(file-name-from-path (string->path "output/fc991453-9476-404d-ae66-ed68bcb52dc2.metadata")) "")
(meta->filename meta)
)
| false |
b377a2c834472834879831c80f4528c6f1c7bc9c | 851142adef050060fb22cb27bb67e7ef308015d6 | /lambs/rkt/slides.rkt | 11c2badc0c4b31ec9df9bb6ba5b6b7f453cf8cdf | []
| no_license | Glorp/lambs-combs | e36f8af33625d371e660469618862d808a56e1da | fd9375b1c8e69a172567fcf34e5c0fdde41d13e8 | refs/heads/master | 2020-05-09T17:34:47.902941 | 2019-05-08T11:36:53 | 2019-05-08T11:36:53 | 181,315,223 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 7,177 | rkt | slides.rkt | #lang at-exp racket
(provide (struct-out static-image)
slides)
(struct static-image (path) #:transparent)
(define-syntax-rule (slds (name stuff ...) ...)
(make-immutable-hash (list (cons 'name (list stuff ...)) ...)))
(define slides
(slds (halp
"C-d: ≜"
"C-l: λ"
""
"C-e: add definition or do one step of evaluation"
""
"like, cursor somewhere on next line and do C-e:"
"I ≜ λx.x"
""
"C-S-e: evaluate until normal form, or at least 1000 steps"
"C-r: replace names of things defined with their definitions"
""
"like, cursor on next line, C-r, then C-e or C-S-e:"
"I I I I foo"
""
"renaming variables to avoid capture counts as one step:"
"like,"
"λx.(λy.λx.y) x"
""
"anyway blah blah combinators. So can instead do:"
"I x ≜ x"
"and so on."
""
"..."
""
"<C-return>: special command thing (lines that begin with :)"
""
"some examples..."
":draw (λf.λx.f x) foo bar"
":scale"
":scale 2"
":draw (λx.x) foo"
":border-length"
":border-length 5"
":slide hello")
(hello
"hello?"
""
"(some notes to a self:"
"border-length, textsize stuffs?"
"did I switch out \"temp\" with sth?)")
(lamb-syntax
"exp u ::= x variable"
" λx.u abstraction"
" u1 u2 application")
(lamb-computation
"(λx.u1) u2"
"[u2/x]u1"
""
"e.g."
"(λx.x) foo"
""
"(λa.λb.λc.a c c) foo bar quux")
(lambda-churchnums
"nums like:"
"l0 ≜ λf.λx.x"
"l1 ≜ λf.λx.f x"
"l2 ≜ λf.λx.f (f x)"
"l3 ≜ λf.λx.f (f (f x))"
"l4 ≜ λf.λx.f (f (f (f x)))"
"l5 ≜ λf.λx.f (f (f (f (f x))))"
""
"and like functions like successor"
"lsuc ≜ λn.λf.λx.f (n f x)"
"and plus"
"l+ ≜ λa.λb.λf.λx.a f (b f x)"
"and stuff")
(schon
" It is in the spirit of the axiomatic method as it has now"
" received recognition, chiefly through the work of Hilbert,"
" that we not only strive to keep the axioms as few and"
" their content as limited as possible but also attempt to"
" make the number of fundamental undefined notions as small"
" as we can; we do this by seeking out those notions from"
" which we shall best be able to construct all other notions"
" of the branch of science in question."
""
" On the building blocks of mathematical logic"
" Moses Schönfinkel")
(combs
"for like our purposes:"
"a combinator is a function with no free variables"
""
"e.g."
"λx.x"
"λa.λb.a"
"λf.λx.f (f x)"
""
"but not e.g."
"λx.f x")
(comb-rules
"but also syntax:"
"I x ≜ x"
"BLAH x y z ≜ BLAH z y x"
""
"and then e.g."
"I foo"
"BLAH foo bar quux"
"BLAH foo bar")
(ski
"S x y z ≜ (x z) (y z)"
"(or S ≜ λx.λy.λz.(x z) (y z))"
""
"K x y ≜ x"
"(or K ≜ λx.λy.x)"
""
"I x ≜ x"
"(or I ≜ λx.x)")
(iks
"I x ≜ x"
"I is the identity function"
""
"K x y ≜ x"
"we can use K to make constant functions"
"e.g. (K 1) is the function that always returns 1"
""
"S x y z ≜ (x z) (y z)"
"S is like, oof, stuff...")
(try-to-ski
"we can try to turn som lambdas into SKI")
(maybe-doable
"λx.x"
"λf.λx.x"
"λa.λb.λc.c")
(maybe-harder
"λa.λb.λc.b"
"λf.λx.f x"
"λf.λx.x f")
(tried-to-ski
"translate by gradually rewriting and testing with dummy args"
""
"\"abstraction elimination\""
""
"replace a lambda abstraction with a combinator that's been"
"given all but one of its arguments"
""
"I and K not so bad"
"λx.x => I"
"λx.u, if no free x in u => K u")
(s
"S x y z ≜ (x z) (y z)"
""
"in translating we pass inn two arguments (all but one)"
"so the z will kind of replace the original lambda-parameter")
(s-fun
"S x y z ≜ (x z) (y z)"
""
"function applications consists of two things"
"function-part-thing and argument-part-thing"
""
"the z will then be passed into both so _those_ need to be"
"made into functions accepting the original lambda parameter")
(aid-understanding
"\"To sum up, Point-Free helps you tidy your code into more"
"concise implementations which tend to aid you in"
"understanding what it is you are trying to do.\"")
(ski-rules
"λx.x => I"
"λx.u, if no free x in u => K u"
"λx.u1 u2 => S (λx.u1) (λx.u2)")
(eta
"λx.f x is the same as f as long as there is no free x in x")
(ski-eta-rules
"λx.x => I"
"λx.u, if no free x in u => K u"
"λx.u x, if no free x in u => u"
"λx.u1 u2 => S (λx.u1) (λx.u2)")
(many-ks
"while translating we often get stuff like"
"λf.λx.K (f x)"
"which we then turn into"
"λf.S (K K) f"
""
"and the K K bit seems maybe silly"
"like there was nothing really important going on in there?"
""
"would be nice if we could just like _not_ throw additional"
"Ks onto uninteresting stuff")
(bc
"B x y z ≜ x (y z)"
"C x y z ≜ (x z) y")
(skibc-rules
"λx.x => I"
"λx.u, if no free x in u => K u"
"λx.u x, if no free x in u => u"
"λx.u1 u2,"
" if no free x in u1 => B u1 (λx.u2)"
" if no free x in u2 => C (λx.u1) u2"
" else => S (λx.u1) (λx.u2)")
(fewer
"we could do like S K K instead of I"
""
"there's some stuff about having maybe just one combinator"
"which you can kind of do. but we don't"
""
"says Schönfinkel:"
"\"But on account of its obvious arbitrariness it is"
"probably without any real significance.\"")
(hask
"foo x y = (x + y) / 2")
(link? "code: https://github.com/Glorp/lambs-combs")))
| true |
c94d3754a57cabbcca14c859a1658487cf658b4c | fc22bffe6fd01f0045ade778d3ea534acb6f9e48 | /chapter03/Exercise 3.68.rkt | 01c118d7a8576a89f6157d4d81d0e7233a8fcd3e | []
| no_license | HuTongsama/sicp | 0cd9eafed8bb03e71b4e005ff4382629fc63894f | ba722200ebc81e6fe2fd6d4c47893f36420c0f2e | refs/heads/master | 2021-07-23T06:05:01.884911 | 2020-05-06T15:26:47 | 2020-05-06T15:26:47 | 159,015,398 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 160 | rkt | Exercise 3.68.rkt | #lang racket
;Louis' implementation will recurse infinitely
;because their is no delay in (pairs (stream-cdr s)
;(stream-cdr t)), it will be called recursively. | false |
4b059199751904c89d855f7870bbf0641cbea112 | 60b6707dbd61950877e4a7fd8c3cc627efb79a5b | /examples/pattern-match/case.rkt | 0cfb95b8b0f46fa029af2fdeb5565e6c75b9adaa | []
| no_license | chrisnevers/racket-compiler | 536e2a4aa3e8bc71c5637bc887a1bdb6084d0e43 | 900d190b1ca4046a39047e18682a623324e7f68a | refs/heads/master | 2020-03-28T17:24:06.380557 | 2019-05-03T21:02:58 | 2019-05-03T21:02:58 | 148,785,877 | 7 | 0 | null | 2019-02-04T17:59:34 | 2018-09-14T12:32:58 | OCaml | UTF-8 | Racket | false | false | 245 | rkt | case.rkt | (define-type MyType
(inty Int)
(vecy (Vector Bool Int)))
(define (print-bool [x : MyType]) : Bool
(case x
((inty i) (zero? i))
((vecy v) (not (vector-ref v 0)))))
(let ((x (vecy (vector #f 3))))
(print-bool x))
| false |
afe02bdeed7a063772e5a0c2dc9a8b55d5097e76 | 37858e0ed3bfe331ad7f7db424bd77bf372a7a59 | /experiments/so/1ed_s/experiment-3_wrap-conde.rkt | 65a7929c0e8340ea7e6adc432122a887762708ae | []
| no_license | chansey97/the-reasoned-schemer | ecb6f6a128ff0ca078a45e097ddf320cd13e81bf | a6310920dde856c6c98fbecec702be0fbc4414a7 | refs/heads/main | 2023-05-13T16:23:07.738206 | 2021-06-02T22:24:51 | 2021-06-02T22:24:51 | 364,944,122 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 825 | rkt | experiment-3_wrap-conde.rkt | #lang racket
(require "../../../book/1ed_s/libs/minikanren/minikanren.rkt")
(require "../../../book/1ed_s/common.rkt")
(define (tmp-rel y)
(conde
((== 'c y) )
((tmp-rel-2 y))))
(define (tmp-rel-2 y)
(conde ((== 'd y) (tmp-rel-2 y)))) ; wrap a suspension by conde
(run 2 (r)
(fresh (x y)
(conde
((== 'a x) (tmp-rel y))
((== 'b x) (conde
((== 'e y) )
((== 'f y)))))
(== `(,x ,y) r)))
;; => '((a c) (b e))
(run 3 (r)
(fresh (x y)
(conde
((== 'a x) (tmp-rel y))
((== 'b x) (conde
((== 'e y) )
((== 'f y)))))
(== `(,x ,y) r)))
;; => '((a c) (b e) (b f))
| false |
2d14bcf1e88f1674b30bf52a9c43627cc7429e72 | eb6764a89076805e8ee2f5f6a5be5720ac0397b8 | /rkt/blog.rkt | d32c26c387badcc5eff55c1078613679695f842b | []
| no_license | brooksbp/snippets | ad8fa19f505528ba47499640407b37ed928503bf | ad9d61251a9e78075af3ede5d7a2fb09a2658b80 | refs/heads/master | 2021-10-10T01:54:10.175654 | 2019-01-06T04:52:42 | 2019-01-06T04:52:42 | 1,210,248 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 4,742 | rkt | blog.rkt | #lang racket
(require web-server/servlet
web-server/servlet-env
web-server/formlets
"model-3.rkt")
(provide/contract (start (request? . -> . response?)))
; start: request -> response
(define (start request)
(render-blog-page
(initialize-blog! (build-path "/home/brian/proj/rktweb/the-blog-data-sql3.db"))
request))
(define new-post-formlet
(formlet
(#%# ,{input-string . => . title}
,{input-string . => . body})
(values title body)))
; render-blog-page: blog request -> response
; Consumes a blog and a request, and produces an HTML page
; of the content of the blog.
(define (render-blog-page a-blog request)
(local [(define (response-generator embed/url)
(response/xexpr
`(html (head (title "My Blog"))
(link ((rel "stylesheet")
(href "style.css")
(type "text/css")))
(body
(h1 "My Blog")
,(render-posts a-blog embed/url)
(form ([action
,(embed/url insert-post-handler)])
,@(formlet-display new-post-formlet)
(input ([type "submit"])))))))
(define (insert-post-handler request)
(define-values (title body)
(formlet-process new-post-formlet request))
(blog-insert-post! a-blog title body)
(render-blog-page a-blog (redirect/get)))]
(send/suspend/dispatch response-generator)))
(define new-comment-formlet
input-string)
(define (render-post-detail-page a-blog a-post request)
(local [(define (response-generator embed/url)
(response/xexpr
`(html (head (title "Post Details"))
(body
(h1 "Post Details")
(h2 ,(post-title a-post))
(p ,(post-body a-post))
,(render-as-itemized-list (post-comments a-post))
(form ([action
,(embed/url insert-comment-handler)])
,@(formlet-display new-comment-formlet)
(input ([type "submit"])))
(a ((href ,(embed/url back-handler)))
"back")))))
(define (insert-comment-handler request)
(render-confirm-add-comment-page
a-blog
(formlet-process new-comment-formlet request)
a-post
request))
(define (back-handler request)
(render-blog-page a-blog request))]
(send/suspend/dispatch response-generator)))
(define (render-confirm-add-comment-page a-blog a-comment
a-post request)
(local [(define (response-generator embed/url)
(response/xexpr
`(html (head (title "Add a Comment"))
(body
(h1 "Add a Comment")
"The comment: " (div (p ,a-comment))
"will be added to "
(div ,(post-title a-post))
(p (a ((href ,(embed/url yes-handler))) "Yes!"))
(p (a ((href ,(embed/url cancel-handler))) "No!"))))))
(define (yes-handler request)
(post-insert-comment! a-blog a-post a-comment)
(render-post-detail-page a-blog a-post (redirect/get)))
(define (cancel-handler request)
(render-post-detail-page a-blog a-post request))]
(send/suspend/dispatch response-generator)))
(define (render-post a-blog a-post embed/url)
(local [(define (view-post-handler request)
(render-post-detail-page a-blog a-post request))]
`(div ((class "post"))
(a ((href ,(embed/url view-post-handler)))
,(post-title a-post))
(p ,(post-body a-post))
(div ,(number->string (length (post-comments a-post)))
" comment(s)"))))
(define (render-posts a-blog embed/url)
(local [(define (render-post/embed/url a-post)
(render-post a-blog a-post embed/url))]
`(div ((class "posts"))
,@(map render-post/embed/url (blog-posts a-blog)))))
(define (render-as-itemized-list fragments)
`(ul ,@(map render-as-item fragments)))
(define (render-as-item a-fragment)
`(li ,a-fragment))
(serve/servlet start
#:launch-browser? #f
#:quit? #f
#:listen-ip #f
#:port 8080
#:extra-files-paths
(list (build-path "/home/brian/proj/rktweb/static/"))
#:servlet-regexp #rx"") | false |
d152a0191190dd1d5d780042e64a20de9621f48f | cc01edd31885c9431d33c7f79dc9e63809a35e51 | /Assignment10/my_work_with_answer_tests.rkt | 9cfb75ebf0bd9b69e5d8f60c231c29d6edf7e4bc | []
| no_license | abriggs914/CS3613 | 4bba00ed9b74c904a20d24b01745b2e412b4d639 | 496d931fdaa49d60ef83be27c790b5e9dc309b28 | refs/heads/master | 2020-04-15T20:12:03.721710 | 2019-04-27T02:11:01 | 2019-04-27T02:11:01 | 164,982,788 | 0 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 3,403 | rkt | my_work_with_answer_tests.rkt | #lang plait
;; Solution for tutorial 7
(define-type Object
[object (refs : (Listof Number))]
[primitive])
(define-type-alias Heap (Vectorof Object))
(define-type-alias LocSet (Setof Number))
(define-type-alias (Setof 'a) (Hashof 'a Boolean))
(define (list->set [ items : (Listof 'a) ]) : (Setof 'a)
(hash (map (lambda (item) (pair item #t)) items)))
(define-syntax-rule (set x ...)
(list->set (list x ...)))
(define (set-member? [set : (Setof 'a)] [thing : 'a]) : Boolean
(type-case (Optionof Boolean) (hash-ref set thing)
[(some val) val]
[else #f]))
(define (set-add [set : (Setof 'a)] [thing : 'a]) : (Setof 'a)
(hash-set set thing #t))
(define (set-union [the-set : (Setof 'a)] [other-set : (Setof 'a)])
(foldl
(lambda (thing set) (set-add set thing))
the-set
(hash-keys other-set)))
(define (visitObject [n : Number] [h : Heap] [acc : (Listof Number)]) : (Listof Number)
(let ([len (vector-length h)])
(cond
[(>= n len)
(error 'visitObject "Given an index greater than vector length.")]
[(< n 0)
(error 'visitObject "Given a negative index value.")]
[else (type-case Object (vector-ref h n)
[(primitive) acc]
[(object ref) ref])])))
(define (search-one-root [n : Number] [h : Heap]) : LocSet
(let ([lst (visitObject n h (list n))]
[e empty])
(list->set
(append (list n)
(append lst (foldl
(lambda (x acc)
(visitObject x h (append acc e)))
e
(visitObject n h e)))))))
(define (find-live [lst : (Listof Number)] [h : Heap]) : LocSet
(let ([res
(append lst
(foldl
(lambda (x acc)
(append acc (visitObject x h empty)))
empty lst))])
(list->set res)))
(module+ test
(test (list->set empty) (hash empty))
(define S123 (list->set '(1 2 3)))
(test S123 (hash (list (pair 1 #t) (pair 2 #t) (pair 3 #t))))
(test (set) (list->set empty))
(test (set 1 2 3) S123)
(test (set-member? S123 1) #t)
(test (set-member? S123 10) #f)
(test (set-add (set 1 2 3) 0) (set 0 1 2 3))
(test (set-union (set 0 1 2 3) (set -1 2 7)) (set -1 0 1 2 3 7)))
(define heap1
(vector
(object (list 1 2))
(primitive)
(object (list 2))))
(define heap2
(vector
(object (list 0 1))
(object (list 2))
(object (list 0))))
(module+ test
(test (search-one-root 0 heap1) (set 0 1 2))
(test (search-one-root 1 heap1) (set 1))
(test (search-one-root 0 heap2) (set 0 1 2))
(test (search-one-root 1 heap2) (set 0 1 2)))
(module+ test
(test (find-live '(1) heap1) (set 1))
(test (find-live '(0) heap1) (set 0 1 2))
(test (find-live '(1 2) heap2) (set 0 1 2))
(define heap4
(vector
(object (list 3))
(object (list 3 4))
(object (list 4 5))
(object (list 0))
(primitive)
(primitive)))
(test (search-one-root 1 heap4) (set 0 1 3 4))
(test (search-one-root 2 heap4) (set 2 4 5))
(test (search-one-root 3 heap4) (set 0 3))
(test (search-one-root 5 heap4) (set 5))
(test (find-live '(1) heap4) (set 0 1 3 4))
(test (find-live '(2) heap4) (set 2 4 5))
(test (find-live '(1 2) heap4) (set 0 1 2 3 4 5))
(test (find-live '(3 4) heap4) (set 0 3 4)))
(define minutes-spent 120) | true |
d8d127f8440d63ce7de83348a0fe133b43562c5c | e3cfbb9a978d3ac739d7a623bc8982d3dee1ba64 | /if-hacker-news-mentions-emacs-then-mail-me.rkt | 1808f346447b0db0f5a03b63f0dde61b6b8c100d | []
| no_license | xuchunyang/learn-racket | 7cbeb1545c519705bb8759851c2d104760163203 | 13ca916e5eafa7f4de141034fe65a2f99c2b7f71 | refs/heads/master | 2020-03-22T17:10:47.754872 | 2020-01-17T17:24:08 | 2020-01-17T17:24:08 | 140,378,786 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,437 | rkt | if-hacker-news-mentions-emacs-then-mail-me.rkt | #lang racket
(require html-parsing
net/url
sxml
openssl
net/head
net/smtp)
(struct story (title url) #:prefab)
;; 返回 HN 上所有提及 Emacs 的主题，如果一个也没有，返回 '()
(define (mentions-emacs)
(define-values (status headers html)
(http-sendrecv/url (string->url "https://news.ycombinator.com/")))
(define xexp (html->xexp html))
(define stories
(map
(lambda (node)
(let ((top (cons '*TOP* (list node))))
(story (car ((sxpath "/a/text()") top))
(car ((sxpath "/a/@href/text()") top)))))
((sxpath "//a[@class='storylink']") xexp)))
(filter (lambda (a-story) (regexp-match #rx"(?i:emacs)" (story-title a-story)))
stories))
(define (mail-me subject body)
(define from "if-hacker-news-mentions-emacs-then-mail-me.rkt <[email protected]>")
(define to (list "Myself <[email protected]>"))
(define header (standard-message-header
from
to
'()
'()
subject))
(parameterize ([smtp-sending-end-of-message
(lambda () (printf "mail '~a' sent!\n" subject))])
(smtp-send-message "smtp.mail.me.com"
from
to
header
;; body should be a string
(string-split body "\n")
#:port-no 587
#:auth-user "[email protected]"
#:auth-passwd (get-password)
#:tls-encode ports->ssl-ports)))
(define (get-password)
(call-with-input-file (expand-user-path "~/.authinfo")
(lambda (in)
(let/cc return
(for ([s (in-lines in)])
(let ((match (regexp-match "machine smtp.mail.me.com .*password ([^ ]+)"
s)))
(when match
(return (second match)))))))))
(module+ test
(require rackunit)
(test-case "忽略大小写"
(check-not-false (regexp-match #rx"(?i:emacs)" "emacs"))
(check-not-false (regexp-match #rx"(?i:emacs)" "Emacs"))
(check-not-false (regexp-match #rx"(?i:emacs)" "EMACS")))
(test-case "获得密码"
(check-true (string? (get-password)))))
(define (shell-command-to-string command)
(string-trim (with-output-to-string (lambda () (system command)))))
(module+ test
(check-equal? (shell-command-to-string "echo hello") "hello"))
(module+ main
(let loop ([new-stories (mentions-emacs)]
[old-stories empty])
(define really-new-storis
(filter (lambda (a-story) (not (member a-story old-stories)))
new-stories))
(define now (shell-command-to-string "date"))
(cond [(empty? new-stories)
(printf "[~a] Hacker News 上没有提及 Emacs 的主题\n" now)]
[(empty? really-new-storis)
(printf "[~a] Hacker News 上没有提及 Emacs 的新主题\n" now)]
[else
(printf "[~a] 发现主题，准备发送邮件...\n"
(shell-command-to-string "date"))])
(map (lambda (a-story)
(mail-me (story-title a-story)
(story-url a-story)))
really-new-storis)
(printf "[~a] sleep...\n"
(shell-command-to-string "date"))
(sleep 300)
(loop (mentions-emacs) (append really-new-storis old-stories))))
| false |
517fd7e9d80b50b8045c0005bbb698abd058c85c | 9c36ed1e52d7712599a8cb0e80fd5ac94d328bd3 | /src/web/pages.rkt | 3f7d3e626f38c11ea6954861e167637bda418e2d | [
"MIT"
]
| permissive | oflatt/herbie | e7db30968537f9b03430056408babbcca77f411f | cecba081914fb685fcd962a95c6d6fcaa7f063ad | refs/heads/master | 2021-07-30T03:37:47.191038 | 2021-07-23T19:10:19 | 2021-07-23T19:10:19 | 211,983,144 | 0 | 0 | NOASSERTION | 2019-10-01T00:26:43 | 2019-10-01T00:26:43 | null | UTF-8 | Racket | false | false | 3,632 | rkt | pages.rkt | #lang racket
(require (only-in fpbench fpcore? supported-by-lang? core->js js-header) json)
(require "../alternative.rkt" "../syntax/read.rkt" "../sandbox.rkt" "../interface.rkt")
(require "common.rkt" "timeline.rkt" "plot.rkt" "make-graph.rkt" "traceback.rkt" "../programs.rkt"
"../syntax/sugar.rkt")
(provide all-pages make-page page-error-handler)
(define (unique-values pts idx)
(length (remove-duplicates (map (curryr list-ref idx) pts))))
(define (all-pages result)
(define test (test-result-test result))
(define good? (test-success? result))
(define others
(if good?
(let ([other (cdr (test-success-end-alts result))]
[vars (test-vars test)])
(if (and good? (< (* (length other) (length vars)) 100))
(build-list (length other) (λ (x) (format "o~a" x)))
'()))
'()))
(define pages
`("graph.html"
,(and good? "interactive.js")
"timeline.html" "timeline.json"
,@(for/list ([v (test-vars test)] [idx (in-naturals)]
#:when good? [type (append (list "" "r" "g" "b") others)]
#:unless (and (equal? type "g") (not (test-output test)))
;; Don't generate a plot with only one X value else plotting throws an exception
#:when (> (unique-values (test-success-newpoints result) idx) 1))
(format "plot-~a~a.png" idx type))
,(and good? (>= (length (test-success-end-alts result)) 2) "cost-accuracy.png")))
(filter identity pages))
(define ((page-error-handler result page) e)
(define test (test-result-test result))
((error-display-handler)
(format "Error generating `~a` for \"~a\":\n~a\n" page (test-name test) (exn-message e))
e))
(define (make-page page out result profile?)
(define test (test-result-test result))
(define repr (test-output-repr test))
(match page
["graph.html"
(match result
[(? test-success?) (make-graph result out (get-interactive-js result repr) profile?)]
[(? test-timeout?) (make-traceback result out profile?)]
[(? test-failure?) (make-traceback result out profile?)])]
["interactive.js"
(make-interactive-js result out repr)]
["timeline.html"
(make-timeline (test-name test) (test-result-timeline result) out)]
["timeline.json"
(write-json (test-result-timeline result) out)]
["cost-accuracy.png"
(make-cost-accuracy-plot result out)]
[(regexp #rx"^plot-([0-9]+).png$" (list _ idx))
(make-axis-plot result out (string->number idx))]
[(regexp #rx"^plot-([0-9]+)([rbg]).png$" (list _ idx letter))
(make-points-plot result out (string->number idx) (string->symbol letter))]
[(regexp #rx"^plot-([0-9]+)(o[0-9]+).png$" (list _ idx letter))
(make-points-plot result out (string->number idx) letter)]))
(define (get-interactive-js result repr)
(define start-prog (alt-program (test-success-start-alt result)))
(define end-prog (alt-program (car (test-success-end-alts result))))
(define start-fpcore (program->fpcore (resugar-program start-prog repr)))
(define end-fpcore (program->fpcore (resugar-program end-prog repr)))
(and (fpcore? start-fpcore) (fpcore? end-fpcore)
(supported-by-lang? start-fpcore "js")
(supported-by-lang? end-fpcore "js")
(string-append
(js-header "Math") ; pow, fmax, fmin will not work without this
(core->js start-fpcore "start")
(core->js end-fpcore "end"))))
(define (make-interactive-js result out repr)
(define js-text (get-interactive-js result repr))
(when (string? js-text)
(display js-text out)))
| false |
392b99602be315506c00a61e03b9141a3370ed81 | c01a4c8a6cee08088b26e2a2545cc0e32aba897b | /medikanren2/neo/dbKanren/test/test-low-level.rkt | 9dc1a1b92e30dbee550eb3d608317f2709095b3e | [
"MIT"
]
| permissive | webyrd/mediKanren | c8d25238db8afbaf8c3c06733dd29eb2d7dbf7e7 | b3615c7ed09d176e31ee42595986cc49ab36e54f | refs/heads/master | 2023-08-18T00:37:17.512011 | 2023-08-16T00:53:29 | 2023-08-16T00:53:29 | 111,135,120 | 311 | 48 | MIT | 2023-08-04T14:25:49 | 2017-11-17T18:03:59 | Racket | UTF-8 | Racket | false | false | 25,311 | rkt | test-low-level.rkt | #lang racket/base
(provide
query:Known->Known
query:Known->X
query:X->Known
query:Known<-X->Known
query:Known->X->Known
query:X->Y->Known
query:Concept
concept-properties
concept-property-values
curie->properties
edge-properties
edge-property-values
edge-id->properties)
(require "../dbk/database.rkt" "../dbk/enumerator.rkt" "../dbk/stream.rkt"
racket/fixnum racket/match racket/pretty racket/runtime-path racket/set)
;; Control whether data is preloaded from disk and kept in-memory.
;; NOTE: without preloading, thread-safety is not guaranteed by default.
(define preload-index? #f)
(define str.predicate "predicate")
;(define str.predicate "edge_label")
(define (dict-get d key)
(dict-ref d key (lambda (v) v) (lambda () (error "dict-get failed" key))))
(define (string*->id=>1 str*) (bytes*->id=>1 (map string->bytes/utf-8 str*)))
(define (bytes*->id=>1 text*)
(let* ((text* (sort (set->list (list->set text*)) bytes<?))
(id* (list->vector (map text->id text*))))
(dict:ref (lambda (i) (vector-ref id* i)) fx<
(lambda (_) '()) 0 (vector-length id*))))
(define (string->id str) (text->id (string->bytes/utf-8 str)))
(define (id->string id) (bytes->string/utf-8 (id->text id)))
(define (text->id b) (initialize-text!) (dict-get (thread-cell-ref tcell.text=>id) b))
(define (id->text id) (initialize-text!) (dict-get (thread-cell-ref tcell.id=>text) id))
(define (concept-properties) (map id->string (enumerator->list
(dict-key-enumerator ckey=>cvalue=>curie=>1))))
(define (edge-properties) (map id->string (enumerator->list
(dict-key-enumerator ekey=>evalue=>eid=>1))))
(define (concept-property-values key) (s-map id->string (enumerator->s
(dict-key-enumerator
(dict-get ckey=>cvalue=>curie=>1
(string->id key))))))
(define (edge-property-values key) (s-map id->string (enumerator->s
(dict-key-enumerator
(dict-get ekey=>evalue=>eid=>1
(string->id key))))))
(define (curie->properties curie)
(enumerator->list
(lambda (yield)
((dict-enumerator (dict-get curie=>ckey=>cvalue=>1 (string->id curie)))
(lambda (ckey cvalue=>1)
(yield (map id->string (cons ckey (enumerator->list
(dict-key-enumerator cvalue=>1))))))))))
(define (edge-id->properties eid)
(enumerator->list
(lambda (yield)
((dict-enumerator (dict-get eid=>ekey=>evalue=>1 eid))
(lambda (ekey evalue=>1)
(yield (map id->string (cons ekey (enumerator->list
(dict-key-enumerator evalue=>1))))))))))
;; query:Known->X is analogous to a miniKanren-style query with this shape:
; (run* (s sname p o oname)
; (fresh (id category)
; (edge id s o)
; (cprop o "category" category)
; (cprop s "name" sname)
; (cprop o "name" oname)
; (eprop id "predicate" p)
; (membero s subject-curies)
; (membero p predicates)
; (membero category object-categories)))
(define (query:Known->X curie*.K predicate*.K->X category*.X)
(define (query. yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K)))
((merge-join fx< K=>1 subject=>object=>eid=>1)
(lambda (id.K __ X=>eid=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< X=>eid=>1 curie=>ckey=>cvalue=>1)
(lambda (id.X eid=>1 ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
((dict-key-enumerator eid=>1)
(lambda (eid)
(let ((predicate.K->X
(id->string (dict-min (dict-get (dict-get eid=>ekey=>evalue=>1 eid)
ekey.predicate)))))
(yield (list* K name.K predicate.K->X X name.X
(edge-id->properties eid))))))))))))))
(define (query.c yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.category (string->id "category"))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(category=>1 (string*->id=>1 category*.X))
(category=>curie=>1 (dict-get ckey=>cvalue=>curie=>1 ckey.category)))
((merge-join fx< K=>1 subject=>object=>eid=>1)
(lambda (id.K __ X=>eid=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< category=>1 category=>curie=>1)
(lambda (__ ___ X=>1.cprop)
((merge-join fx< X=>eid=>1 X=>1.cprop)
(lambda (id.X eid=>1 __)
(let* ((id.name.X (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.X)
ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
((dict-key-enumerator eid=>1)
(lambda (eid)
(let ((predicate.K->X
(id->string (dict-min (dict-get (dict-get eid=>ekey=>evalue=>1 eid)
ekey.predicate)))))
(yield (list* K name.K predicate.K->X X name.X
(edge-id->properties eid))))))))))))))))
(define (query.p yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(predicate=>1 (string*->id=>1 predicate*.K->X))
(predicate=>eid=>1 (dict-get ekey=>evalue=>eid=>1 ekey.predicate)))
((merge-join fx< K=>1 subject=>eid=>object=>1)
(lambda (id.K __ eid=>X=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< predicate=>1 predicate=>eid=>1)
(lambda (id.predicate.K->X __ eid=>1)
(let ((predicate.K->X (id->string id.predicate.K->X)))
((merge-join fx< eid=>1 eid=>X=>1)
(lambda (eid __ X=>1.edge)
((merge-join fx< X=>1.edge curie=>ckey=>cvalue=>1)
(lambda (id.X __ ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
(yield (list* K name.K predicate.K->X X name.X
(edge-id->properties eid))))))))))))))))
(define (query.p&c yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.category (string->id "category"))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(predicate=>1 (string*->id=>1 predicate*.K->X))
(category=>1 (string*->id=>1 category*.X))
(predicate=>eid=>1 (dict-get ekey=>evalue=>eid=>1 ekey.predicate))
(category=>curie=>1 (dict-get ckey=>cvalue=>curie=>1 ckey.category)))
((merge-join fx< K=>1 subject=>eid=>object=>1)
(lambda (id.K __ eid=>X=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< predicate=>1 predicate=>eid=>1)
(lambda (id.predicate.K->X __ eid=>1)
(let ((predicate.K->X (id->string id.predicate.K->X)))
((merge-join fx< eid=>1 eid=>X=>1)
(lambda (eid __ X=>1.edge)
((merge-join fx< category=>1 category=>curie=>1)
(lambda (__ ___ X=>1.cprop)
((dict-join-ordered
(lambda (yield)
((merge-join fx< X=>1.cprop X=>1.edge)
(lambda (id.X __ ___)
(yield id.X '()))))
curie=>ckey=>cvalue=>1)
(lambda (id.X __ ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
(yield (list* K name.K predicate.K->X X name.X
(edge-id->properties eid))))))))))))))))))
(time (enumerator->rlist (if predicate*.K->X
(if category*.X query.p&c query.p)
(if category*.X query.c query.)))))
;; query:X->Known is analogous to a miniKanren-style query with this shape:
; (run* (s sname p o oname)
; (fresh (id category)
; (edge id s o)
; (cprop s "category" category)
; (cprop s "name" sname)
; (cprop o "name" oname)
; (eprop id "predicate" p)
; (membero o object-curies)
; (membero p predicates)
; (membero category subject-categories)))
(define (query:X->Known category*.X predicate*.X->K curie*.K)
(define (query. yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K)))
((merge-join fx< K=>1 object=>subject=>eid=>1)
(lambda (id.K __ X=>eid=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< X=>eid=>1 curie=>ckey=>cvalue=>1)
(lambda (id.X eid=>1 ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
((dict-key-enumerator eid=>1)
(lambda (eid)
(let ((predicate.X->K
(id->string (dict-min (dict-get (dict-get eid=>ekey=>evalue=>1 eid)
ekey.predicate)))))
(yield (list* X name.X predicate.X->K K name.K
(edge-id->properties eid))))))))))))))
(define (query.c yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.category (string->id "category"))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(category=>1 (string*->id=>1 category*.X))
(category=>curie=>1 (dict-get ckey=>cvalue=>curie=>1 ckey.category)))
((merge-join fx< K=>1 object=>subject=>eid=>1)
(lambda (id.K __ X=>eid=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< category=>1 category=>curie=>1)
(lambda (__ ___ X=>1.cprop)
((merge-join fx< X=>eid=>1 X=>1.cprop)
(lambda (id.X eid=>1 __)
(let* ((id.name.X (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.X)
ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
((dict-key-enumerator eid=>1)
(lambda (eid)
(let ((predicate.X->K
(id->string (dict-min (dict-get (dict-get eid=>ekey=>evalue=>1 eid)
ekey.predicate)))))
(yield (list* X name.X predicate.X->K K name.K
(edge-id->properties eid))))))))))))))))
(define (query.p yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(predicate=>1 (string*->id=>1 predicate*.X->K))
(predicate=>eid=>1 (dict-get ekey=>evalue=>eid=>1 ekey.predicate)))
((merge-join fx< K=>1 object=>eid=>subject=>1)
(lambda (id.K __ eid=>X=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< predicate=>1 predicate=>eid=>1)
(lambda (id.predicate.X->K __ eid=>1)
(let ((predicate.X->K (id->string id.predicate.X->K)))
((merge-join fx< eid=>1 eid=>X=>1)
(lambda (eid __ X=>1.edge)
((merge-join fx< X=>1.edge curie=>ckey=>cvalue=>1)
(lambda (id.X __ ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
(yield (list* X name.X predicate.X->K K name.K
(edge-id->properties eid))))))))))))))))
(define (query.p&c yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.category (string->id "category"))
(ckey.name (string->id "name"))
(K=>1 (string*->id=>1 curie*.K))
(predicate=>1 (string*->id=>1 predicate*.X->K))
(category=>1 (string*->id=>1 category*.X))
(predicate=>eid=>1 (dict-get ekey=>evalue=>eid=>1 ekey.predicate))
(category=>curie=>1 (dict-get ckey=>cvalue=>curie=>1 ckey.category)))
((merge-join fx< K=>1 object=>eid=>subject=>1)
(lambda (id.K __ eid=>X=>1)
(let* ((id.name.K (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.K) ckey.name)))
(name.K (id->string id.name.K))
(K (id->string id.K)))
((merge-join fx< predicate=>1 predicate=>eid=>1)
(lambda (id.predicate.X->K __ eid=>1)
(let ((predicate.X->K (id->string id.predicate.X->K)))
((merge-join fx< eid=>1 eid=>X=>1)
(lambda (eid __ X=>1.edge)
((merge-join fx< category=>1 category=>curie=>1)
(lambda (__ ___ X=>1.cprop)
((dict-join-ordered
(lambda (yield)
((merge-join fx< X=>1.cprop X=>1.edge)
(lambda (id.X __ ___)
(yield id.X '()))))
curie=>ckey=>cvalue=>1)
(lambda (id.X __ ckey=>cvalue=>1)
(let* ((id.name.X (dict-min (dict-get ckey=>cvalue=>1 ckey.name)))
(name.X (id->string id.name.X))
(X (id->string id.X)))
(yield (list* X name.X predicate.X->K K name.K
(edge-id->properties eid))))))))))))))))))
(time (enumerator->rlist (if predicate*.X->K
(if category*.X query.p&c query.p)
(if category*.X query.c query.)))))
;; query:Known<-X->Known is analogous to a miniKanren-style query with this shape:
;(run* (K1 name.K1 predicates.K1<-X X name.X predicates.X->K1 K2 name.K2)
; (fresh (id1 id2 category.X)
; (edge id1 X K1)
; (edge id2 X K2)
; (cprop X "category" category.X)
; (cprop X "name" name.X)
; (cprop K1 "name" name.K1)
; (cprop K2 "name" name.K2)
; (eprop id1 "predicate" K1<-X)
; (eprop id2 "predicate" X->K2)
; (membero category.X categories.X)
; (membero K1 curies.K1)
; (membero K1<-X predicates.K1<-X)
; (membero K2 curies.K2)
; (membero X->K2 predicates.X->K2)))
(define (query:Known<-X->Known curie*.K1 predicate*.K1<-X category*.X predicate*.X->K2 curie*.K2)
(define (candidate*->dict candidate*)
(let* ((candidate* (sort candidate* (lambda (a b) (string<? (car a) (car b)))))
(group* (list->vector (s-group candidate* equal? car)))
(ref.value (lambda (i) (vector-ref group* i))))
(dict:ref (lambda (i) (caar (ref.value i))) string<?
ref.value 0 (vector-length group*))))
(let* ((X=>XK1=>1 (candidate*->dict (query:X->Known category*.X predicate*.K1<-X curie*.K1)))
(X=>XK2=>1 (candidate*->dict (query:X->Known category*.X predicate*.X->K2 curie*.K2))))
(time (enumerator->list
(lambda (yield)
((merge-join string<? X=>XK1=>1 X=>XK2=>1)
(lambda (X XK1* XK2*)
(for-each
(lambda (XK1)
(match-define (list* _ name.X predicate.X->K1 K1 name.K1 props1) XK1)
(for-each
(lambda (XK2)
(match-define (list* _ _ X->K2 K2 name.K2 props2) XK2)
(yield (append (list K1 name.K1 predicate.X->K1 X name.X X->K2 K2 name.K2)
(append props1 props2))))
XK2*))
XK1*))))))))
(define (query:Known->X->Known curie*.K1 predicate*.K1->X category*.X predicate*.X->K2 curie*.K2)
(define (KX*->dict candidate*)
(let* ((candidate* (sort candidate* (lambda (a b) (string<? (cadddr a) (cadddr b)))))
(group* (list->vector (s-group candidate* equal? cadddr)))
(ref.value (lambda (i) (vector-ref group* i))))
(dict:ref (lambda (i) (cadddr (car (ref.value i)))) string<?
ref.value 0 (vector-length group*))))
(define (XK*->dict candidate*)
(let* ((candidate* (sort candidate* (lambda (a b) (string<? (car a) (car b)))))
(group* (list->vector (s-group candidate* equal? car)))
(ref.value (lambda (i) (vector-ref group* i))))
(dict:ref (lambda (i) (caar (ref.value i))) string<?
ref.value 0 (vector-length group*))))
(let* ((X=>K1X* (KX*->dict (query:Known->X curie*.K1 predicate*.K1->X category*.X)))
(X=>XK2* (XK*->dict (query:X->Known category*.X predicate*.X->K2 curie*.K2))))
(time (enumerator->list
(lambda (yield)
((merge-join string<? X=>K1X* X=>XK2*)
(lambda (X K1X* XK2*)
(for-each
(lambda (K1X)
(match-define (list* K1 name.K1 predicate.X->K1 _ name.X props1) K1X)
(for-each
(lambda (XK2)
(match-define (list* _ _ X->K2 K2 name.K2 props2) XK2)
(yield (append (list K1 name.K1 predicate.X->K1 X name.X X->K2 K2 name.K2)
(append props1 props2))))
XK2*))
K1X*))))))))
(define (query:X->Y->Known category*.X predicate*.X->Y category*.Y predicate*.Y->K curie*.K)
(define (result*->dict key result*)
(let* ((result* (sort result* (lambda (a b) (string<? (key a) (key b)))))
(group* (list->vector (s-group result* equal? key)))
(ref.value (lambda (i) (vector-ref group* i))))
(dict:ref (lambda (i) (key (car (ref.value i)))) string<?
ref.value 0 (vector-length group*))))
(let* ((Y=>YK=>1 (result*->dict car (query:X->Known category*.Y predicate*.Y->K curie*.K)))
(curie*.Y (enumerator->list (dict-key-enumerator Y=>YK=>1)))
(Y=>XY=>1 (result*->dict cadddr (query:X->Known category*.X predicate*.X->Y curie*.Y))))
(time (enumerator->list
(lambda (yield)
((merge-join string<? Y=>XY=>1 Y=>YK=>1)
(lambda (Y XY* YK*)
(for-each
(lambda (XY)
(match-define (list* X name.X predicate.X->Y _ name.Y props.X->Y) XY)
(for-each
(lambda (YK)
(match-define (list* _ _ Y->K K name.K props.Y->K) YK)
(yield (append (list X name.X predicate.X->Y Y name.Y Y->K K name.K)
(append props.X->Y props.Y->K))))
YK*))
XY*))))))))
(define (query:Known->Known curie*.S predicate*.S->O curie*.O)
(query:dict.Known->dict.Known
(string*->id=>1 curie*.S) predicate*.S->O (string*->id=>1 curie*.O)))
(define (query:dict.Known->dict.Known curie=>1.S predicate*.S->O curie=>1.O)
(define (query yield)
(let* ((ekey.predicate (string->id str.predicate))
(ckey.name (string->id "name"))
(predicate=>1 (string*->id=>1 predicate*.S->O))
(predicate=>eid=>1 (dict-get ekey=>evalue=>eid=>1 ekey.predicate)))
((merge-join fx< curie=>1.S subject=>eid=>object=>1)
(lambda (id.S __ eid=>O=>1)
(let* ((id.name.S (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.S) ckey.name)))
(name.S (id->string id.name.S))
(S (id->string id.S)))
((merge-join fx< predicate=>1 predicate=>eid=>1)
(lambda (id.predicate.S->O __ eid=>1)
(let ((predicate.S->O (id->string id.predicate.S->O)))
((merge-join fx< eid=>1 eid=>O=>1)
(lambda (eid __ O=>1)
((merge-join fx< curie=>1.O O=>1)
(lambda (id.O __ ___)
(let* ((id.name.O (dict-min (dict-get (dict-get curie=>ckey=>cvalue=>1 id.O)
ckey.name)))
(name.O (id->string id.name.O))
(O (id->string id.O)))
(yield (list* S name.S predicate.S->O O name.O
(edge-id->properties eid))))))))))))))))
(time (enumerator->rlist query)))
(define (query:Concept curie*)
(define (query yield)
(let ((curie=>1 (string*->id=>1 curie*)))
((merge-join fx< curie=>1 curie=>ckey=>cvalue=>1)
(lambda (id.curie _ ckey=>cvalue=>1)
(let ((curie (id->string id.curie)))
((dict-enumerator ckey=>cvalue=>1)
(lambda (id.key cvalue=>1)
(yield (list curie (id->string id.key) (id->string (dict-min cvalue=>1)))))))))))
(time (enumerator->list query)))
(define-runtime-path path.here ".")
(define db (database (build-path path.here "name-of-your-database.db")))
(define r.cprop (database-relation db 'cprop))
(define r.edge (database-relation db 'edge))
(define r.eprop (database-relation db 'eprop))
(define tcell.text=>id (make-thread-cell #f))
(define tcell.id=>text (make-thread-cell #f))
(define (initialize-text!)
(unless (thread-cell-ref tcell.text=>id)
(define-values (text=>id id=>text) (relation-text-dicts r.cprop #f))
(thread-cell-set! tcell.text=>id text=>id)
(thread-cell-set! tcell.id=>text id=>text)))
(displayln "Loading relation index dictionaries")
(define subject=>object=>eid=>1 (time (relation-index-dict r.edge '(subject object eid) preload-index?)))
(define object=>subject=>eid=>1 (time (relation-index-dict r.edge '(object subject eid) preload-index?)))
(define subject=>eid=>object=>1 (time (relation-index-dict r.edge '(subject eid object) preload-index?)))
(define object=>eid=>subject=>1 (time (relation-index-dict r.edge '(object eid subject) preload-index?)))
(define ekey=>evalue=>eid=>1 (time (relation-index-dict r.eprop '(key value eid) preload-index?)))
(define eid=>ekey=>evalue=>1 (time (relation-index-dict r.eprop '(eid key value) preload-index?)))
(define ckey=>cvalue=>curie=>1 (time (relation-index-dict r.cprop '(key value curie) preload-index?)))
(define curie=>ckey=>cvalue=>1 (time (relation-index-dict r.cprop '(curie key value) preload-index?)))
| false |
823043dd93d32ae0de2cf87d75bbfaa1551ec748 | b08b7e3160ae9947b6046123acad8f59152375c3 | /Programming Language Detection/Experiment-2/Dataset/Train/Racket/polymorphism.rkt | 9828aaa9b6dfe92e4cf0fcbf08268e7c1248eb7c | []
| no_license | dlaststark/machine-learning-projects | efb0a28c664419275e87eb612c89054164fe1eb0 | eaa0c96d4d1c15934d63035b837636a6d11736e3 | refs/heads/master | 2022-12-06T08:36:09.867677 | 2022-11-20T13:17:25 | 2022-11-20T13:17:25 | 246,379,103 | 9 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 670 | rkt | polymorphism.rkt | #lang racket
(define point%
(class* object% (writable<%>) (super-new) (init-field [x 0] [y 0])
(define/public (copy) (new point% [x x] [y y]))
(define/public (show) (format "<point% ~a ~a>" x y))
(define/public (custom-write out) (write (show) out))
(define/public (custom-display out) (display (show) out))))
(define circle%
(class point% (super-new) (inherit-field x y) (init-field [r 0])
(define/override (copy) (new circle% [x x] [y y] [r r]))
(define/override (show) (format "<circle% ~a ~a>" (super show) r))
(define/override (custom-write out) (write (show) out))
(define/override (custom-display out) (display (show) out))))
| false |
8329858d67c390d22d3107abb587d51a7324ee19 | e81628d750a321352f60e33b997e595831bc2b59 | /2_19/continuation_ri.rkt | f762e6f27a1724a674f0be2243afdc08b5ba2054 | []
| no_license | renfrog/C311Sp19 | 2eaecdbcd87ead5ee98aad96ccc94574da2e3b49 | 30bb06645186bdd5082b50e8fa37d859a096841d | refs/heads/master | 2020-05-07T11:01:18.727677 | 2019-04-09T16:25:49 | 2019-04-09T16:25:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,021 | rkt | continuation_ri.rkt | #lang racket
(require racket/trace)
(define apply-k
(λ (k v)
(match k
[`(fib-sub2-k ,v^ ,k)
(apply-k k (+ v^ v))]
[`(fib-sub1-k ,n ,k)
(fib-cps (sub1 (sub1 n))
(make-fib-sub2-k v k))]
[`(id-k) v]
[`(rator-k ,rand ,env ,k)
(valof-cps rand
env
(make-rand-k v k))]
[`(rand-k ,c ,k)
(c v k)]
#;
[whatever (k v)])))
(define make-fib-sub2-k
(λ (v^ k) #|free variables: v k|#
`(fib-sub2-k ,v^ ,k)
#;
(λ (w) (apply-k k (+ v^ w)))))
(define make-fib-sub1-k
(λ (n k) #|free variables: n k|#
`(fib-sub1-k ,n ,k)
#;
(λ (v)
(fib-cps (sub1 (sub1 n))
(make-fib-sub2-k v k)))))
(define make-id-k
(λ () #|free variables: None|#
`(id-k)
#;
(λ (v) v)))
(define fib-cps
(λ (n k)
(cond
[(zero? n) (apply-k k 1)]
[(zero? (sub1 n)) (apply-k k 1)]
[else (fib-cps (sub1 n) (make-fib-sub1-k n k))])))
(trace fib-cps)
#;
(fib-cps 5 (make-id-k))
(define make-rator-k
(λ (rand env k) #|fv: rand env k|#
`(rator-k ,rand ,env ,k)
#;
(λ (c)
(valof-cps rand
env
(make-rand-k c k)))))
(define make-rand-k
(λ (c k) #|fv: c k|#
`(rand-k ,c ,k)
#;
(λ (a)
(c a k))))
(define valof-cps
(λ (exp env k)
(match exp
[`,y
#:when (symbol? y)
(env y k)]
[`,n
#:when (number? n)
(apply-k k n)]
[`(λ (,x) ,body)
(apply-k k (λ (a k)
(valof-cps body
(λ (y k) (if (eqv? y x)
(apply-k k a)
(env y k)))
k)))]
[`(,rator ,rand)
(valof-cps rator
env
(make-rator-k rand env k))])))
(valof-cps '(((λ (x) (λ (y) y)) 5) 6)
(λ (y) (error "oopsie"))
(make-id-k))
| false |
eef7506e28f0bb0e3eff80ba3e4adb88a15866e7 | 627680558b42ab91471b477467187c3f24b99082 | /chapters/related-work/related-work.scrbl | 82e6b7131a9fe6cfac1d142334854138345b36e7 | []
| no_license | bfetscher/dissertation | 2a579aa919d6173a211560e20630b3920d108412 | 148d7f9bb21ce29b705522f7f4967d63bffc67cd | refs/heads/master | 2021-01-12T12:57:45.507113 | 2016-10-06T06:54:21 | 2016-10-06T06:54:21 | 70,130,350 | 0 | 1 | null | 2016-10-06T14:01:38 | 2016-10-06T06:58:19 | Racket | UTF-8 | Racket | false | false | 12,643 | scrbl | related-work.scrbl | #lang scribble/base
@(require scriblib/figure
scribble/manual
scriblib/footnote
slideshow/pict
"citations.rkt")
@title[#:tag "sec:related"]{Related Work}
Work related to the constraint solver is addressed in
@secref["sec:related-dqs"], and studies on random testing
most closely related to those of this work are discussed
in @secref["sec:benchmark-why"]. This chapter discusses
related work in random and property-based testing and
its application in semantics engineering.
@section[#:tag "sec:related-testing"]{Property-based Testing}
Quickcheck@~cite[QuickCheck] is a widely-used library
for random testing in Haskell. It provides combinators supporting the
definition of testable properties, random generators, and analysis
of results. Although Quickcheck's approach is much more general than
the one taken here, it has been used to implement a random generator
for well-typed terms robust enough to find bugs in GHC@~cite[palka-diss].
This generator provides a good contrast to the approach of this work,
as it was implemented by hand, albeit with the assistance of a powerful
test framework. Significant effort was spent on adjusting the distribution
of terms and optimization, even adjusting the type system in clever
ways. Redex's approach, on the other hand, is to provide a straightforward
way to implement a test generator. The relationship to Pałka's work is discussed
in more detail in @secref["sec:ghc"], including a direct comparison
on a few of the properties tested by @citet[palka-diss].
SmallCheck and Lazy SmallCheck@~cite[small-check] are other Haskell libraries
for property-based testing. They differ from QuickCheck in that they
use exhaustive testing instead of random testing. Lazy SmallCheck is
particularly successful, using partial evaluation to prune the space
from which test cases are drawn based on the property under test.
They also perform a comparative evaluation of SmallCheck, Lazy SmallCheck,
and QuickCheck.
Perhaps the most closely related work is @citet[uniform]'s
typed term generator. Their work addresses specifically the
problem of generating well-formed lambda terms based an
implementation of a type-checker (in Haskell). They measured
their approach against property 1 from @secref["sec:ghc"]
and it performs better than Redex's 'poly' generator, but they are
working from a lower-level specification of the type system.
Also, their approach observes the order of
evaluation of the predicate, and prunes the search space
based on that; it does not use constraint solving.
Efficient random generation of abstract data types has seen some interesting
advances in previous years, much of which focuses on enumerations.
Feat@~cite[feat], or ``Functional Enumeration of Algebraic Types,'' is a
Haskell library that exhaustively enumerates a datatype's possible values.
The enumeration is made very efficient by memoising cardinality metadata,
which makes it practical to access values that have very large indexes.
The enumeration also weights all terms equally, so a random sample of values
can in some sense be said to have a more uniform distribution. Feat was used
to test Template Haskell by generating AST values, and compared favorably with
Smallcheck in terms of its ability to generate terms above a certain size.
(QuickCheck was excluded from this particular case study because it was
``very difficult'' to write a QuickCheck generator for ``mutual recursive
datatypes of this size'', the size being around 80 constructors. This provides
some insight into the effort involved in writing the generator described
in @citet[palka-diss].)
Another, more specialized, approach to enumerations was taken by
@citet[counting-lambdas]. Their work addresses specifically the problem
of enumerating well-formed lambda terms. (Terms where all variables
are bound.) They present a variety of combinatorial results on
lambda terms, notably some about the extreme scarcity of simply-typable
terms among closed terms. As a by-product they get an efficient generator
for closed lambda terms. To generate typed terms their approach
is simply to filter the closed terms with a typechecker. This approach
is somewhat inefficient (as one would expect due to the rarity of typed
terms) but it does provide a uniform distribution.
Instead of enumerating terms, @citet[every-bit-counts] develop a
bit-coding scheme where every string of bits either corresponds
to a term or is the prefix of some term that does. Their approach
is quite general and can be used to encode many different types.
They are able to encode a lambda calculi with polymorphically-typed
constants and discuss its possible extension to even more challenging
languages such as System-F. This method cannot be used for random generation
because only bit-strings that have a prefix-closure property correspond
to well-formed terms.
SciFe@~cite[scife] is a Scala library providing combinators that enable
the construction of enumerations similar to those of @secref["sec:enum"].
@citet[scife] conduct a study comparing generation speed for 5 data structures
with nontrivial invariants such a red-black trees or sorted lists. They compare
their approach, the CLP approach described by @citet[clp-test], and
Korat@~cite[korat], and find that their approach is the fastest at exhaustively
generating structures up to a given size.
@citet[clp-test] study the application of CLP to the exhaustive generation
of several different data structures, including red-black trees and
sorted lists. They report on a comparison with Korat@~cite[korat], finding
that their approach is faster than Korat at enumerating all inhabitants
of such constrained types below a given size bound. They also include an
in-depth discussion of how to efficiently implement CLP generators, including
the application of several optimization passes.
Korat@~cite[korat] is an approach to exhaustive testing in Java that uses
a form of state-space filtering to generate data types satisfying general
structural invariants in Java. The authors perform a study comparing its
performance at generating all valid types of a certain size with the Allow Analyzer,
an auotmated analysis tool for a relational specification language. The comparison
is performed using red-black trees, binary heaps, and other data structures.
@;{
@section[#:tag "sec:lightweight"]{Lightweight tools for semantics}
K - @citet[k-overview]
Maude - @citet[maude2]
Ott - @citet[ott]
Lem - @citet[lem]
ASF+SDF - @citet[asf+sdf]}
@section[#:tag "sec:other"]{Testing and Checking Semantics}
Random program generation for testing a semantics or programming language
implementation is certainly not a new idea, and goes back as least to
the ``syntax machine'' of @citet[Hanford], a tool for producing random
expressions from a grammar similar to the ad-hoc generation method of
@secref["sec:ad-hoc"]. The tool was intended for compiler fuzzing, a common
use for that type of random generation. Other applications of random testing to
compilers throughout the years are discussed in the 1997 survey of
@citet[compiler-testing].
In the area of random testing for compilers, of special note is Csmith@~cite[csmith]
a highly effective tool at generating C programs for compiler testing.
Csmith generates C programs that avoid undefined or unspecified behavior.
These programs are then used for differential testing, where the output of a
given program is compared across several compilers and levels of optimization,
so that if the results differ, at least one of test targets must contain a bug.
Csmith represents a significant development effort at 40,000+ lines of C++
and the programs it generates are finely tuned to be effective at finding
bugs based on several years of experience. It had
found over 300 bugs in mainstream C compilers as of 2011.
@citet[αProlog-test] design an automated model-checking framework based on
αProlog@~cite[αProlog], a programming language based on nominal logic,
designed for modeling formal systems.
They advocate automating mechanized checking for semantics in a manner
similar to this work, although their approach is different,
performing exhaustive checking up to some bound on model size.
They conduct a study demonstrating their approach's ability to find bugs in
both the substitution function and the typing judgment of a small
lambda calculus modeled in αProlog. For comparison, the bugs they evaluate
in the substitution function are very similar to @bold{stlc-sub} bugs
1 and 2 from the Redex benchmark, and the type judgment bugs are
very similar to @bold{stlc} or
@bold{poly-stlc} bugs 3 and 9, all of which were found by most
generators in this paper in interactive time periods as well.
@;{
Both exhaustive testing and model-checking methods of automated checking
require imposing an arbitrary size or state space bound, justified by the ``small
scope hypothesis''@~cite[jackson-book], which asserts that any fault can be
exposed with a small counterexample. Of course, even random testing
methods require the specification of some bound on counterexample size,
but it can typically be much larger. Does the small scope hypothesis always apply?
It seems that larger test cases have the potential to be more
efficient at finding bugs by testing multiple aspects of a system at the
same time, or exposing bugs that require interactions between subsystems
that would be difficult to trigger with small bugs. Such concerns would seem
to grow with the scale of the program under test. In fact, @citet[csmith]
find that when testing production C compilers, which are quite large compared
to examples such as red-black tree implementations used in many studies of this
type of testing, extremely large tests cases are the most efficient.
(Programs averaging around 81KB, or containing around 8K-16K tokens, maximized
the rate at which they found counterexamples.)}
Other recent work also applies constraint logic programming to test programming
language semantics and implementations.
@citet[clp-language-fuzzing] conduct a study using CLP to generate
Javascript programs with richer constraints than traditional grammar-based
fuzzers, but less complex than full type soundness. They target specific
variants of test cases, such as the use of prototype-based inheritance or
combinations of @tt{with} statements with closures. They perform a comparison
with a baseline stochastic grammar generator, making a convincing case
that CLP is an improvement for this type of language fuzzing.
A related study@~cite[clp-data-structures] demonstrates that CLP can be
competitive with the most efficient known methods for generating
data structures such as red-black trees, skip lists, and B-trees.
The same approach is used in @citet[rusty-fuzz] to find bugs in the Rust
typechecker, by specifying a system that will usually
(but not always)@note{For example, the specification of System F used
as an example in the paper uses a definition of
substitution that is not capture-avoiding, which
simplifies implementation and generation speed at
the cost of sometimes producing terms that are
not well-typed.}
generate well-typed terms.
Isabelle/HOL@~cite[isabelle] is a proof assistant equipped with a logic
designed to support semantics modeling. Significant work has been done
to equip Isabelle with automatic testing and checking capabilities similar
to those in Redex, although in a proof-assistant as opposed to a
lightweight modeling context. It has support for random testing via
an implementation of QuickCheck@~cite[isabelle-quickcheck-orig] and two
methods of model checking, Nitpick@~cite[nitpick] and Refute@~cite[weber-dissertation].
Property-based testing in Isabelle has recently been extended to try a
number of different strategies by @citet[isabelle-quickcheck-bulwahn], adding
exhaustive testing, symbolic testing, and a narrowing-based strategy.
@citet[isabelle-quickcheck-bulwahn] also conducts a study comparing the
different methods of test-case generation, similar to that of this
dissertation.
The K Framework@~cite[overview-k k-overview] is a lightweight semantics
modeling framework with sophisticated rewriting rules. It provides
testing via executability (as in Redex) as a well as model checking in a linear
temporal logic, symbolic execution, and verification based on reachability
using matching logic. It has been used to model, test, and check/verify
a number of different programming languages, including C@~cite[c-k],
Java@~cite[k-java], and Javascript@~cite[k-js].
| false |
801f2a1a2dc790f4c3c299f9b438a1298cc3fdae | 9209079c67b9efa4a8e619f0621165bac930c82d | /sicp/chapter1/ex-1.31(pi-count).rkt | 93339f2d1423c6aa3ed284e1d9bf4b16bb263daa | []
| no_license | AlexMost/my-courses | c29c5c65bae36245443c8f95a076e6cdfb6703fe | 3d9148879399232312244d7b0b61a06690ee8cca | refs/heads/master | 2021-01-18T22:09:24.416646 | 2018-07-05T22:09:48 | 2018-07-05T22:09:48 | 21,182,354 | 2 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 917 | rkt | ex-1.31(pi-count).rkt | #lang racket
(define (cube x) (* x x x))
(define (inc x) (+ 1 x))
(define (id x) x)
; mul iterative
(define (mul term a next b)
(define (iter a result)
(if (> a b)
result
(iter (next a) (* result (term a)))))
(iter a 1))
; mul recursive
(define (mul-rec term a next b)
(if (> a b) 1
(* (term a) (mul-rec term (next a) next b))))
(define (mul-simple a b)
(mul id a inc b))
(define (mul-rec-simple a b)
(mul-rec id a inc b))
; factorial
(define (factorial n) (mul-simple 1 n))
(define (pi-next n)
(if (even? n)
(/ (+ n 2) (+ n 1))
(/ (+ n 1) (+ n 2))))
; pi count iterative
(define (pi n)
(exact->inexact (* (mul pi-next 1 inc n) 4)))
; pi count recursive
(define (pi-rec n)
(exact->inexact (* (mul-rec pi-next 1 inc n) 4)))
; > (pi 100)
; 3.1570301764551676
; > (pi 200)
; 3.1493784731686008
; > (pi 1000)
; 3.1431607055322663
; > (pi 1000000) | false |
d3cc4bd159ebc1eb93ab8f39972d862de409b807 | ea4fc87eafa7b36a43f8f04b9585d73aeed1f036 | /laramie-lib/parser/parameters.rkt | a8b979e147857bbfd911bb7762da7857570e25df | [
"MIT"
]
| permissive | jthodge/laramie | a58a551727aebc792bdcaa5193dff775fd9848df | 7afc9314ff1f363098efeb68ceb25e2e9c419e6e | refs/heads/master | 2023-06-19T21:19:43.308293 | 2021-07-19T05:20:01 | 2021-07-19T05:20:01 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,699 | rkt | parameters.rkt | #lang typed/racket/base
(provide current-parser-state
raise-parse-error!
turn-on-quirks!
drop-token!
scripting-enabled?
current-context-node-for-fragment)
(require (file "types.rkt")
(file "../tokenizer/types.rkt"))
(define (initial-parser-state)
(parser-state (list)
(list)
(list)
(document-node (list) #f)
#f
#t
(list)
#f
#f
(list)
#f
(list 'initial)))
(: current-parser-state (Parameter parser-state))
(define current-parser-state (make-parameter (initial-parser-state)))
(: current-context-node-for-fragment (Parameter (Option element-node)))
(define current-context-node-for-fragment (make-parameter #f))
(: scripting-enabled? (Parameter Boolean))
(define scripting-enabled? (make-parameter #f))
(: drop-token! (-> Token
Void))
(define (drop-token! token)
(define s (current-parser-state))
(current-parser-state
(struct-copy parser-state
s
[dropped (cons token (parser-state-dropped s))])))
(: raise-parse-error! (-> (U tokenizer-error
parser-error)
Void))
(define (raise-parse-error! err)
(define s (current-parser-state))
(current-parser-state
(struct-copy parser-state
s
[errors (cons err (parser-state-errors s))])))
(: turn-on-quirks! (-> Void))
(define (turn-on-quirks!)
(current-parser-state
(struct-copy parser-state
(current-parser-state)
[quirky? #t])))
| false |
51133d5eb66b74a49d7225b4dd61f046838ba061 | 5f83eb0c32f15aeed5993a3ad5ededb6f31fe7aa | /racket/riscv/encoding/gen.rkt | 3635d9adcc445f626aca13df2c095808f776f6c0 | []
| no_license | uw-unsat/jitterbug | 45b54979b156c0f5330012313052f8594abd6f14 | 78d1e75ad506498b585fbac66985ff9d9d05952d | refs/heads/master | 2023-07-11T09:15:21.433725 | 2023-06-18T04:10:48 | 2023-07-03T20:12:41 | 244,440,882 | 46 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 134 | rkt | gen.rkt | #lang racket/base
(require web-server/templates
"bpf_jit.generated.c.rkt")
(displayln (include-template "bpf_jit.h.tmpl"))
| false |
a51596d3bcdcde10a33215799b1e3b16df265c5c | 94e9923b043132127488bf59887a156d976e2207 | /ex_2_18.rkt | dc472def4cc3685db64516ac46d0a4dbc189b864 | []
| no_license | pbruyninckx/sicp | 31b5a76cf9a06a0bb24bd8d7b75353c1eb6358b9 | 133e2ac911a3345594ae265661d7d15f0c1927c9 | refs/heads/master | 2020-04-18T18:27:57.961188 | 2019-10-19T12:14:06 | 2019-10-19T12:14:06 | 167,684,388 | 1 | 1 | null | null | null | null | UTF-8 | Racket | false | false | 153 | rkt | ex_2_18.rkt | #lang racket
(define (reverse l)
(define (helper l acc)
(if (null? l)
acc
(helper (cdr l) (cons (car l) acc))))
(helper l '()))
| false |
858c7de360b1ffd8df3bdecd82928a11d637f241 | 898dceae75025bb8eebb83f6139fa16e3590eb70 | /pl1/asg2/osx-dist/lib/plt/assignment2-osx/collects/racket/contract/private/basic-opters.rkt | 4406e5eb4e458f15706a9a548cefd916aa05274c | []
| no_license | atamis/prog-hw | 7616271bd4e595fe864edb9b8c87c17315b311b8 | 3defb8211a5f28030f32d6bb3334763b2a14fec2 | refs/heads/master | 2020-05-30T22:17:28.245217 | 2013-01-14T18:42:20 | 2013-01-14T18:42:20 | 2,291,884 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,979 | rkt | basic-opters.rkt | #lang racket/base
(require "guts.rkt"
"blame.rkt"
"opt.rkt"
"misc.rkt")
(require (for-syntax racket/base
"opt-guts.rkt"))
;;
;; opt/pred helper
;;
(define-for-syntax (opt/pred opt/info pred)
(with-syntax ((pred pred))
(build-optres
#:exp
(with-syntax ((val (opt/info-val opt/info))
(ctc (opt/info-contract opt/info))
(blame (opt/info-blame opt/info)))
(syntax (if (pred val)
val
(raise-opt/pred-error blame val 'pred))))
#:lifts null
#:superlifts null
#:partials null
#:flat (syntax (pred val))
#:opt #f
#:stronger-ribs null
#:chaperone #t)))
(define (raise-opt/pred-error blame val pred-name)
(raise-blame-error
blame
val
'(expected: "~a")
pred-name))
;;
;; built-in predicate opters
;;
(define/opter (null? opt/i opt/info stx) (opt/pred opt/info #'null?))
(define/opter (boolean? opt/i opt/info stx) (opt/pred opt/info #'boolean?))
(define/opter (string? opt/i opt/info stx) (opt/pred opt/info #'string?))
(define/opter (integer? opt/i opt/info stx) (opt/pred opt/info #'integer?))
(define/opter (char? opt/i opt/info stx) (opt/pred opt/info #'char?))
(define/opter (number? opt/i opt/info stx) (opt/pred opt/info #'number?))
(define/opter (pair? opt/i opt/info stx) (opt/pred opt/info #'pair?))
(define/opter (not opt/i opt/info stx) (opt/pred opt/info #'not))
(define/opter (real? opt/i opt/info stx) (opt/pred opt/info #'real?))
;;
;; any/c
;;
(define/opter (any/c opt/i opt/info stx)
(syntax-case stx (any/c)
[any/c
(build-optres #:exp (opt/info-val opt/info)
#:lifts null
#:superlifts null
#:partials null
#:flat #'#t
#:opt #f
#:stronger-ribs null
#:chaperone #t)]))
;;
;; false/c
;;
(define/opter (false/c opt/i opt/info stx) (opt/pred opt/info #'not))
;;
;; flat-contract helper
;;
(define-for-syntax (opt/flat-ctc opt/info pred checker)
(syntax-case pred (null? number? integer? boolean? string? pair? not)
;; Better way of doing this?
[null? (opt/pred opt/info pred)]
[number? (opt/pred opt/info pred)]
[integer? (opt/pred opt/info pred)]
[boolean? (opt/pred opt/info pred)]
[string? (opt/pred opt/info pred)]
[pair? (opt/pred opt/info pred)]
[pred
(let* ((lift-vars (generate-temporaries (syntax (pred error-check))))
(lift-pred (car lift-vars)))
(with-syntax ((val (opt/info-val opt/info))
(ctc (opt/info-contract opt/info))
(blame (opt/info-blame opt/info))
(lift-pred lift-pred))
(build-optres
#:exp (syntax (if (lift-pred val)
val
(raise-blame-error
blame
val
'(expected: "~s," given: "~e")
(contract-name ctc)
val)))
#:lifts
(interleave-lifts
lift-vars
(list #'pred (cond [(eq? checker 'check-flat-contract) #'(check-flat-contract lift-pred)]
[(eq? checker 'check-flat-named-contract) #'(check-flat-named-contract lift-pred)])))
#:superlifts null
#:partials null
#:flat (syntax (lift-pred val))
#:opt #f
#:stronger-ribs null
#:chaperone #t)))]))
;;
;; flat-contract and friends
;;
(define/opter (flat-contract opt/i opt/info stx)
(syntax-case stx (flat-contract)
[(flat-contract pred) (opt/flat-ctc opt/info #'pred 'check-flat-contract)]))
(define/opter (flat-named-contract opt/i opt/info stx)
(syntax-case stx (flat-named-contract)
[(flat-named-contract name pred) (opt/flat-ctc opt/info #'pred 'check-flat-named-contract)]))
| false |
f9f887d58899183bb805a010b31d6d9bc4dcdb0c | 25a6efe766d07c52c1994585af7d7f347553bf54 | /gui-doc/mrlib/scribblings/include-bitmap.scrbl | 365024ff70663e4eb327cf2e045bd8cd9a997cde | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/gui | 520ff8f4ae5704210822204aa7cd4b74dd4f3eef | d01d166149787e2d94176d3046764b35c7c0a876 | refs/heads/master | 2023-08-25T15:24:17.693905 | 2023-08-10T16:45:35 | 2023-08-10T16:45:35 | 27,413,435 | 72 | 96 | NOASSERTION | 2023-09-14T17:09:52 | 2014-12-02T03:35:22 | Racket | UTF-8 | Racket | false | false | 1,087 | scrbl | include-bitmap.scrbl | #lang scribble/doc
@(require "common.rkt"
(for-label mrlib/include-bitmap scheme/runtime-path scheme/include))
@title{Include Bitmap}
@defmodule[mrlib/include-bitmap]{The @racket[include-bitmap] form
takes a filename containing a bitmap and ``inlines'' the bitmap into
the program.}
Historically, the advantage of inlining the bitmap is that a
stand-alone executable can be created that contains the bitmap and
does not refer to the original image file. The
@racket[define-runtime-path] form, however, now provides a better
alternative.
@defform*[[(include-bitmap path-spec)
(include-bitmap path-spec type-expr)]]{
The @racket[path-spec] is the same as for @racket[include] form. The
@racket[type-expr] should produce @racket['unknown],
@racket['unknown/mask], etc., as for @racket[bitmap%], and the default
is @racket['unknown/mask].}
@defform*[[(include-bitmap/relative-to source path-spec)
(include-bitmap/relative-to source path-spec [type-expr])]]{
Analogous to @racket[include-at/relative-to], though only a source is
needed (no context).}
| false |
06e12fa68d524c49f24740b1fbb7c0874c12962f | 657061c0feb2dcbff98ca7a41b4ac09fe575f8de | /Racket/Exercises/Week2/fibonacci.rkt | 1d632c3d24ad02eb3cbadc802b95f5446616e90e | []
| no_license | vasil-pashov/FunctionalProgramming | 77ee7d9355329439cc8dd89b814395ffa0811975 | bb998a5df7b715555d3272c3e39b0a7481acf80a | refs/heads/master | 2021-09-07T19:31:05.031600 | 2018-02-27T20:50:44 | 2018-02-27T20:50:44 | 108,046,015 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 124 | rkt | fibonacci.rkt | #lang racket
(define (fib n)
(define (fib* n x1 x2)
(if (= n 1)
x2
(fib* [- n 1] x2 [+ x1 x2])
))
(fib* n 0 1)) | false |
c6a936628819cb9642317e6a21ddc4283ca295ba | 17126876cd4ff4847ff7c1fbe42471544323b16d | /beautiful-racket-demo/bf-demo/expander-slow.rkt | f9abb0abee651baf7e9143b074bcd61f6b33e22e | [
"MIT"
]
| permissive | zenspider/beautiful-racket | a9994ebbea0842bc09941dc6d161fd527a7f4923 | 1fe93f59a2466c8f4842f17d10c1841609cb0705 | refs/heads/master | 2020-06-18T11:47:08.444886 | 2019-07-04T23:21:02 | 2019-07-04T23:21:02 | 196,293,969 | 1 | 0 | NOASSERTION | 2019-07-11T00:47:46 | 2019-07-11T00:47:46 | null | UTF-8 | Racket | false | false | 1,652 | rkt | expander-slow.rkt | #lang br/quicklang
(define-macro (bf-module-begin PARSE-TREE)
#'(#%module-begin
PARSE-TREE))
(provide (rename-out [bf-module-begin #%module-begin]))
(define (fold-funcs apl bf-funcs)
(for/fold ([current-apl apl])
([bf-func (in-list bf-funcs)])
(apply bf-func current-apl)))
(define-macro (bf-program OP-OR-LOOP-ARG ...)
#'(begin
(define first-apl (list (make-vector 30000 0) 0))
(void (fold-funcs first-apl (list OP-OR-LOOP-ARG ...)))))
(provide bf-program)
(define-macro (bf-loop "[" OP-OR-LOOP-ARG ... "]")
#'(lambda (arr ptr)
(for/fold ([current-apl (list arr ptr)])
([i (in-naturals)]
#:break (zero? (apply current-byte
current-apl)))
(fold-funcs current-apl (list OP-OR-LOOP-ARG ...)))))
(provide bf-loop)
(define-macro-cases bf-op
[(bf-op ">") #'gt]
[(bf-op "<") #'lt]
[(bf-op "+") #'plus]
[(bf-op "-") #'minus]
[(bf-op ".") #'period]
[(bf-op ",") #'comma])
(provide bf-op)
(define (current-byte arr ptr) (vector-ref arr ptr))
(define (set-current-byte arr ptr val)
(define new-arr (vector-copy arr))
(vector-set! new-arr ptr val)
new-arr)
(define (gt arr ptr) (list arr (add1 ptr)))
(define (lt arr ptr) (list arr (sub1 ptr)))
(define (plus arr ptr)
(list
(set-current-byte arr ptr (add1 (current-byte arr ptr)))
ptr))
(define (minus arr ptr)
(list
(set-current-byte arr ptr (sub1 (current-byte arr ptr)))
ptr))
(define (period arr ptr)
(write-byte (current-byte arr ptr))
(list arr ptr))
(define (comma arr ptr)
(list (set-current-byte arr ptr (read-byte)) ptr))
| false |
4e276bb9d03a41ba0791f50f0790a0d0b5d2e721 | fc6465100ab657aa1e31af6a4ab77a3284c28ff0 | /results/all/rvm-14-ordered-mildly-unfair.rktd | af16cfdc8e5c98c1c646fd5376ffe764a2919a78 | []
| no_license | maxsnew/Redex-Enum-Paper | f5ba64a34904beb6ed9be39ff9a5e1e5413c059b | d77ec860d138cb023628cc41f532dd4eb142f15b | refs/heads/master | 2020-05-21T20:07:31.382540 | 2017-09-04T14:42:13 | 2017-09-04T14:42:13 | 17,602,325 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 272 | rktd | rvm-14-ordered-mildly-unfair.rktd | (start 2015-06-16T22:05:15 (#:model "rvm-14" #:type ordered-mildly-unfair))
(finished 2015-06-17T22:04:53 (#:model "rvm-14" #:type ordered-mildly-unfair #:time-ms 86400001 #:attempts 96874112 #:num-counterexamples 0 #:rate-terms/s 1121.2281351709707 #:attempts/cexp N/A))
| false |
a1ba00a86a1a204e9e90e546d88719411684c22d | 82c76c05fc8ca096f2744a7423d411561b25d9bd | /typed-racket-test/succeed/gh-issue-1201.rkt | 923ab83439e609fb1aea6b5627510e0e0d6231e6 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/typed-racket | 2cde60da289399d74e945b8f86fbda662520e1ef | f3e42b3aba6ef84b01fc25d0a9ef48cd9d16a554 | refs/heads/master | 2023-09-01T23:26:03.765739 | 2023-08-09T01:22:36 | 2023-08-09T01:22:36 | 27,412,259 | 571 | 131 | NOASSERTION | 2023-08-09T01:22:41 | 2014-12-02T03:00:29 | Racket | UTF-8 | Racket | false | false | 260 | rkt | gh-issue-1201.rkt | #lang typed/racket/base
(define a 10)
;; the type checker recognizes the following pattern as an opt lambda clause
;; see how `aux-table` is created in the function tc/lambda-clause for details.
(define (pos)
(let-values ([(a) (if #f 10 a)])
10))
(pos)
| false |
8da9db3500d147ba53b74cbf10700a0e47d2449e | 925fa95cc25d1d4d9afbe036c2e7b01791f080da | /autopack/http-beta.rkt | 093442b43fb2462927149b26a287be35cd8952ce | []
| no_license | fujingjunben/autopack-racket | 947a7f306f63624320320f7e08df3f89dbf70b8b | d274432f4649792d126c57149468a97f8592d744 | refs/heads/master | 2021-01-10T11:09:18.408427 | 2016-04-08T11:16:24 | 2016-04-08T11:16:24 | 55,772,328 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 5,151 | rkt | http-beta.rkt | #lang racket
(require net/uri-codec)
(require net/url)
(require json)
(require net/http-client)
(provide (all-defined-out))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; interface for api, resource, executor
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;
;;; api
;;;;;;;;
(define host "http://192.168.2.103:8080/auto-packing")
(define api-url (string-append host "/publish/apis"))
(define resource-url (string-append host "/publish/resources"))
(define executor-url (string-append host "/publish/executors"))
(define api-query
; get method
(lambda ((alist '()))
(query api-url alist)))
(define api-create
; post method
(lambda (data #:header (header '("Content-Type: application/x-www-form-urlencoded")))
(create api-url data header)))
(define api-update
; put method
(lambda (params data #:header (header '("Content-Type: application/x-www-form-urlencoded")))
(update api-url params data header)))
(define api-delete
; delete method
(lambda (alist)
(delete api-url alist)))
;;;;;;;;;;;;;;;;;;
;;; resource
;;;;;;;;;;;;;;;;;;
(define resource-query
; get method
(lambda ((alist '()))
(query resource-url alist)))
(define resource-create
; post method
(lambda (data #:header (header '()))
(create resource-url data header)))
(define resource-update
; put method
(lambda (data #:header (header '((charset . "UTF-8"))))
(update resource-url data header)))
(define resource-delete
; delete method
(lambda (alist)
(delete resource-url alist)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; executor
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define executor-query
; get method
(lambda ((alist '()))
(query executor-url alist)))
(define executor-create
; post method
(lambda (data #:header (header '("Content-Type: multipart/form-data")))
(create executor-url data header)))
(define executor-update
; put method
(lambda (params data #:header (header '("Content-Type: application/x-www-form-urlencoded")))
(update executor-url params data header)))
(define executor-delete
; delete method
(lambda (alist)
(delete executor-url alist)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; lib
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (->string bs)
(if (bytes? bs)
(bytes->string/utf-8 bs)
bs))
(define (->bytes str)
(cond
[(string? str)
(string->bytes/utf-8 str)]
[(not str)
#""]
[else
str]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; query, create, update, delete
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define query
(lambda (path params)
(get (string->url
(string-append
path
(if (null? params)
""
(let* ([id (assoc 'id params)]
[rest (remove id params)])
(if id
(string-append "/" (cdr id) "?" (alist->form-urlencoded rest))
(string-append "?" (alist->form-urlencoded rest))))))))))
(define create
(lambda (path data header)
(post path data header)))
(define update
(lambda (path data header)
path
(let* ([id (assoc 'id data)]
[rest (remove id data)])
(post (string-append path "/" (cdr id)) rest header))))
(define delete
(lambda (path params)
(del (string->url
(string-append
path
(let* ([id (assoc 'id params)]
[rest (remove id params)])
(if (null? rest)
(string-append "/" (cdr id))
(string-append "/" (cdr id) "?" (alist->form-urlencoded rest)))))))))
(define post
(lambda (url data header)
(net-op url (make-form data) (make-header header))))
(define del
(lambda (url)
(call/input-url url
delete-pure-port
port->string)))
(define get
(lambda (url)
(call/input-url url
get-pure-port
port->string)))
;;;;;;;;;;;;;;;;;;
;; test
;;;;;;;;;;;;;;;;;;
(define api-key "e6822264802c9620d3ed8ce0dd8f4284")
(define site "https://api.flickr.com/services/rest/")
(define param `((resource_name . "华为")
(version_name . "1.1.8")
(inner_version . "2.0")
(type . "GAME")
(sdk_id . "AndHuaWei")
(for_platform . "Android")
(update_log . "test")
(force_update . "true")
(current_version . "false")
(file . "@And360.zip")))
(define curl (find-executable-path "curl.exe"))
(define gen-params
(lambda (header? sep alist)
(if (null? alist)
'()
(flatten (map (lambda (pair)
(list (if header?
"-H"
"-F")
(string-append (symbol->string (car pair)) sep (cdr pair))))
alist)))))
(define make-form
(lambda (forms)
(gen-params #f "=" forms)))
(define make-header
(lambda (headers)
(gen-params #t ":" headers)))
(define (net-op url param header)
(displayln param)
(apply system*/exit-code (cons curl (append param header (list url))))) | false |
db51918e6a61ea0e739d29bc95a141f509c5a090 | 9b624096ed3f11bd0641404132cb26dc345830b8 | /amazing/basic-machine.rkt | 521774f4f418642e75c50d80a7f34594b97dfe82 | []
| no_license | ashawkey/2019SICP_homework | 258d799e86f59826c826a300e847067506701f7c | e8af8739188efbd248f21866730afef33db7a6b0 | refs/heads/master | 2020-05-22T13:55:06.091098 | 2019-06-06T12:57:00 | 2019-06-06T12:57:00 | 186,370,390 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 4,679 | rkt | basic-machine.rkt | #lang racket
(define ns (make-base-namespace))
(eval '
(define (make-machine regs ops code)
(let ([m (new-machine)])
(m 'add-regs regs)
(m 'add-ops ops)
(m 'set-code code)
m)) ns)
(eval '
(define (new-machine)
(let ([regs (make-hasheq)] [ops (make-hasheq)] [prog #f] [flag #f] [labels (make-hasheq)] [stack (make-hasheq)])
(define (get lst)
(let ([op (car lst)] [arg (cadr lst)])
(lambda ()
(cond
([eq? op 'const] arg)
([eq? op 'op] (hash-ref ops arg))
([eq? op 'reg] (hash-ref regs arg))
([eq? op 'label] (hash-ref labels arg))))))
(define ($nop curr)
(lambda ()
((vector-ref prog (add1 curr)))))
(define ($goto inst)
(set! inst (get inst))
(lambda ()
((vector-ref prog (inst)))))
(define ($test curr args)
(set! args ($apply args))
(lambda ()
(set! flag (args))
((vector-ref prog (add1 curr)))))
(define ($apply thelist)
(set! thelist (map get thelist))
(lambda ()
(apply ((car thelist)) (map (lambda (x) (x)) (cdr thelist)))))
(define ($perform curr args)
(set! args ($apply args))
(lambda ()
(args)
((vector-ref prog (add1 curr)))))
(define ($assign curr args)
(let ([target (car args)])
(set! args (cdr args))
(set! args (if (eq? (caar args) 'op)
($apply args)
(get (car args))))
(lambda ()
(hash-set! regs target (args))
((vector-ref prog (add1 curr))))))
(define ($branch curr inst)
(set! inst (get inst))
(lambda ()
(if flag
((vector-ref prog (inst)))
((vector-ref prog (add1 curr))))))
(define ($save curr name)
(lambda ()
(hash-set! stack name (cons (hash-ref regs name) (hash-ref stack name)))
((vector-ref prog (add1 curr)))))
(define ($restore curr name)
(lambda ()
(hash-set! regs name (car (hash-ref stack name)))
(hash-set! stack name (cdr (hash-ref stack name)))
((vector-ref prog (add1 curr)))))
(lambda (op . args)
(cond
([eq? op 'add-regs]
(for ([reg (car args)])
(hash-set! regs reg #f)
(hash-set! stack reg '())))
([eq? op 'add-ops]
(for ([name (map car (car args))] [func (map cadr (car args))])
(hash-set! ops name func)))
([eq? op 'set-code]
(let ([codes (car args)] [cur 0])
(set! prog (make-vector (add1 (length codes)) #f))
(for ([code codes])
(when (symbol? code)
(hash-set! labels code cur)
(vector-set! prog cur ($nop cur)))
(set! cur (add1 cur)))
(vector-set! prog cur (lambda () (void)))
(set! cur 0)
(for ([code codes])
(when (list? code)
(vector-set! prog cur (cond
([eq? (car code) 'goto] ($goto (cadr code)))
([eq? (car code) 'test] ($test cur (cdr code)))
([eq? (car code) 'branch] ($branch cur (cadr code)))
([eq? (car code) 'perform] ($perform cur (cdr code)))
([eq? (car code) 'test] ($test cur (cdr code)))
([eq? (car code) 'assign] ($assign cur (cdr code)))
([eq? (car code) 'save] ($save cur (cadr code)))
([eq? (car code) 'restore] ($restore cur (cadr code))))))
(set! cur (add1 cur)))))
([eq? op 'reg-set!]
(let ([name (car args)] [value (cadr args)])
(hash-set! regs name value)))
([eq? op 'reg-get]
(hash-ref regs (car args)))
([eq? op 'run]
((vector-ref prog 0))))))) ns)
(eval '(define m 0) ns)
(define (displist lst)
(display (car lst))
(unless (null? (cdr lst))
(display " ")
(displist (cdr lst))))
(let main ([code (read)])
(set! code `(set! m ,code))
(eval code ns)
(displayln "a new machine")
(let loop ([input (read)] [output (read)])
(for ([name (map car input)] [value (map cadr input)])
(eval `(m 'reg-set! ',name ',value) ns))
(eval `(m 'run) ns)
(displist (for/list ([name output])
(eval `(m 'reg-get ',name) ns)))
(newline)
(set! input (read))
(unless (eq? input eof)
(if (and (not (null? input)) (eq? (car input) 'make-machine))
(main input)
(loop input (read))))))
| false |
ea171db98966fcf5e71d9600b2720490ba058dcb | 804e0b7ef83b4fd12899ba472efc823a286ca52d | /apps/coastmed/binding_env/bindings-extensions.rkt | 02fa584fcb8bc4520b39067de1c2597abe2cc515 | []
| no_license | cha63506/CRESTaceans | 6ec436d1bcb0256e17499ea9eccd5c034e9158bf | a0d24fd3e93fc39eaf25a0b5df90ce1c4a96ec9b | refs/heads/master | 2017-05-06T16:59:57.189426 | 2013-10-17T15:22:35 | 2013-10-17T15:22:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 805 | rkt | bindings-extensions.rkt | #lang racket/base
(require COAST)
(provide (all-defined-out))
(define (environs/merge env . envs)
(foldr environ/merge env envs))
(define MESSAGES/RECEIVE
(pairs/environ
environ/null
(list
(define/global/0 'thread-receive thread-receive)
(define/global/1 'delivery? delivery?)
(define/global/1 'delivery/contents-sent delivery/contents-sent)
(define/global/1 'delivery/promise-fulfillment delivery/promise-fulfillment))))
(define MESSAGES/SEND
(pairs/environ
environ/null
(list
(define/global/2 'curl/send curl/send)
(define/global/3 'curl/send/promise curl/send/promise))))
(define DISPLAYING
(pairs/environ
environ/null
(list
(define/global/N 'format format)
(define/global/1 'display display))))
| false |
811a9ca6a19a4785ef0ef3fd9f155e84fedbf8cc | a81d1aca1fdfd0f55282081a27d47478ec128902 | /scribblings/algebraic.scrbl | 237b26ccdacd1bfded372186a004be1df25e4ab7 | [
"MIT"
]
| permissive | intfrr/racket-algebraic | 9eb4ca7ba87db188f6c92580fdbf5f75af0b297d | 399a3945d736f8a5021bbc15c9bd6148e06a0d3e | refs/heads/master | 2020-05-05T12:17:24.632718 | 2019-04-01T01:14:31 | 2019-04-01T01:14:31 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 29,268 | scrbl | algebraic.scrbl | #lang scribble/manual
@title[#:style '(toc)]{Algebraic structures for untyped Racket}
@author{@author+email["Eric Griffis" "[email protected]"]}
@require{./algebraic-includes.rkt}
@(require (for-label (except-in algebraic/racket/base fun?)
racket/contract/base
racket/match
(except-in syntax/parse pattern)))
@; #############################################################################
This package provides @hash-lang[algebraic/racket/base] which extends
@hash-lang[racket/base] with free-form, lexically scoped
@seclink["sec:data"]{algebraic data structures} along with several
@seclink["sec:functions"]{function} and @seclink["sec:macros"]{macro} forms
with uniform and compact destructuring syntax.
@hash-lang[algebraic/racket/base] synthesizes and specializes the
functionality of @racket[struct], @racket[match-lambda], and
@racket[syntax-parser] to streamline the functional programming experience in
vanilla Racket in two key areas:
@subsubsub*section{Consistent Syntax}
The destructuring syntax for algebraic @racket[data] and most other data is
the same for all @tech{function} and @tech{macro} forms.
@subsubsub*section{Full Transparency}
Algebraic data @tech{constructors} are like type tags. When applied to an
argument list, they produce an @tech{instance}---a @deftech{list} or ordered
sequence of unnamed fields with the @tech{constructor} at its head. They are
easy to print and easy to parse, like @rtech{prefab} structs. The main
difference is algebraic @tech{constructors} are lexically scoped and have a
natural ordering.
@table-of-contents[]
@; =============================================================================
@section{Overview}
@; -----------------------------------------------------------------------------
@subsection[#:tag "sec:data"]{Data}
The @racket[data] form defines a variety of procedures and syntax
@rtech{transformers} for working with named @tech{products} and @tech{sums}.
A @deftech{product} identifies a family of structures comprising a @tech{list}
of @deftech{fields}, and a @deftech{sum} is a @tech{list} of @tech{products}.
@example[
(data Peano (Zero Succ))
]
In this example, @racket[Peano] is a @tech{sum} of the @tech{products}
@racket[Zero] and @racket[Succ].
Each @tech{product} name is bound to a @deftech{constructor}, a function that
creates @tech{instances} of the named @tech{product}. An @deftech{instance} is
a concrete expression of the @tech{product} as a tagged tuple of run-time
values or expansion-time syntax fragments.
@example[
(Succ Zero)
(instance? (Succ Zero))
]
Equality is decided structurally for @tech{constructors} and their
@tech{instances}.
@example[
(equal? Succ Succ)
(equal? (Succ Zero) (Succ Zero))
(equal? (Succ Zero) (Succ (Succ Zero)))
]
The @racket[data] form also defines several membership predicates.
@example[
(Succ? Succ)
((sum Peano?) Succ)
((sum Peano?) (sum Peano))
]
To prevent name clashes in types like @racket[Unit], @tech{sum} bindings are
defined in their own @rtech{namespace}. The @racket[sum] form merely adds the
appropriate @rtech{scope} to an identifier.
@; -----------------------------------------------------------------------------
@subsection[#:tag "sec:functions"]{Functions}
A @deftech{function} is a procedure that either deconstructs or rejects a
fully-evaluated argument or argument list. Functions are created with the
single-argument @racket[φ] (or @racket[phi]) and @racket[function] forms, or
their multi-argument variants @racket[φ*] (or @racket[phi*]) and
@racket[function*].
The @racket[φ] (@racket[phi]) form creates a @tech{function} of exactly one
argument with exactly one clause.
@example[
(define inc (φ a (Succ a)))
(define dec (φ (Succ b) b))
(function? inc)
(inc Zero)
(dec (Succ (Succ Zero)))
]
The @racket[φ*] (@racket[phi*]) form creates a @tech{function} of any number
of arguments with exactly one clause.
@example[
(define cmp
(φ* (a b)
((cond [(number? a) <] [(char? a) char<?]) a b)))
(cmp 1 2)
(cmp #\y #\x)
]
The @racket[function] form creates a @tech{function} of exactly one argument
with one or more clauses.
@example[
(define peano
(function [0 Zero]
[n (Succ (peano (- n 1)))]))
(define num
(function [Zero 0]
[(Succ p) (+ 1 (num p))]))
(peano 3)
(num (Succ (Succ (Succ Zero))))
]
The @racket[function*] form creates a @tech{function} of any number of
arguments with one or more clauses.
@example[
(define add
(function* [(a Zero) a]
[(a (Succ b)) (Succ (add a b))]))
(num (add (peano 3) (peano 2)))
]
@tech{Functions} created by @racket[function*] can have clauses with no
arguments, and the number of arguments for each clause can vary.
@example[
(define num-args
(function* [() 0]
[(_ . rest) (+ 1 (apply num-args rest))]))
(num-args)
(num-args - -)
(num-args - - - - -)
]
@; -----------------------------------------------------------------------------
@subsection[#:tag "sec:macros"]{Macros}
A @deftech{macro} is a syntax @rtech{transformer} that either deconstructs or
rejects an argument or argument list at @rtech{expansion} time. Macros are
created with the single-argument @racket[μ] (or @racket[mu]) and
@racket[macro] forms, or the multi-argument variants @racket[μ*] (or
@racket[mu*]) and @racket[macro*].
The @racket[μ] (@racket[mu]) form creates a @tech{macro} of exactly one
argument with exactly one clause.
@example[
(define-syntax infix (μ (a op b) (op a b)))
(infix (5 - 3))
]
The @racket[μ*] (@racket[mu*]) form creates a @tech{macro} of any number of
arguments with exactly one clause.
@example[
(define-syntax --> (μ* (p q) (or (not p) q)))
(for*/list ([p '(#t #f)] [q '(#t #f)]) (--> p q))
]
The @racket[macro] form creates a @tech{macro} of exactly one argument with
one or more clauses.
@example[
(define-syntax bin (macro [#f 0] [_ 1]))
(bin #f)
(bin (values #f))
]
The @racket[macro*] form creates a @tech{macro} of any number of arguments
with one or more clauses.
@example[
(define-syntax and2 (macro* [(a b) ((function [#f #f] [_ b]) a)]))
(define-syntax and*
(macro* [() #t]
[(a b) (and2 a b)]
[(a bs ...) (and2 a (and* bs ...))]))
(and* 2 #f 0)
(and* 2 1 0)
]
@tech{Macros} are designed to simplify mundane meta-programming tasks. The
following example is a run-time implementation of the ``power'' function from
@cite{Taha2004}:
@example[
(define f-power
(function*
[(0 _) 1]
[(n x) (* x (f-power (- n 1) x))]))
(map (curry f-power 3) '(0 1 2 3 4 5 6))
]
With @racket[unsyntax] and the @racket[var] form, applications of the power
function can be unrolled at expansion time.
@example[#:escape UNSYNTAX
(define-syntax m-power
(macro*
[(0 _) 1]
[(1 x) x]
[(n:nat x) (* x (m-power #,(- (var n) 1) x))]))
(define-syntax m-power3 (μ y (m-power 3 y)))
(map (φ x (m-power3 x)) '(0 1 2 3 4 5 6))
]
With @racket[quote] and @racket[local-expand], the generated code can be
exposed.
@example[#:escape UNSYNTAX
(define-syntax q-power
(macro*
[(0 _) 1]
[(1 x) x]
[(n:nat x)
'#,(local-expand #`(* x (q-power #,(- (var n) 1) x))
'expression null)]))
(q-power 3 2)
]
@; =============================================================================
@include-section["algebraic-tutorials.scrbl"]
@; @section[#:tag "tut"]{Tutorial Series: From Models to Interpreters}
@; =============================================================================
@section[#:tag "ref"]{API Reference}
@defmodulelang[algebraic/racket/base]
@; -----------------------------------------------------------------------------
@subsection[#:tag "ref:sums-products"]{Sums and Products}
@defform[
(data sum-decl ...+)
#:grammar [(sum-decl (code:line sum-id (product-id ...)))]
]{
Creates a new @tech{sum} on a @tech{list} of @tech{products} and binds
variables related to them.
A @tech{sum} with @var[n] @tech{products} defines 3+3@var[n] names:
@itemlist[
@item{for each @var[sum-id]:
@itemlist[
@item{a @rtech{transformer} binding that encapsulates information
about the @tech{sum} declaration.}
@item{a @tech{sum} structure that can be printed to retrieve its
definition.}
]
}
@item{@var[sum-id]@tt{?}, for each @var[sum-id]; a predicate that returns
@racket[#t] for the @tech{sum} bound to @var[sum-id], its
@tech{constructors} or their @tech{instances}, and @racket[#f] for any
other value.}
@item{for each @var[product-id]:
@itemlist[
@item{a @rtech{transformer} binding that encapsulates information
about the @tech{product} declaration.}
@item{a @tech{constructor} that takes any number of arguments and
returns a new @tech{instance} of the @tech{product}.}
]
}
@item{@var[product-id]@tt{?}, for each @var[product-id]; a predicate that
returns @racket[#t] for the @tech{constructor} bound to @var[product-id]
or its instances and @racket[#f] for any other value.}
]
Example:
@example[
(data Unit (Unit))
(Unit? Unit)
(Unit? (Unit))
((sum Unit?) Unit)
((sum Unit?) (sum Unit))
]
}
@defform[(sum id)]{
Adds the @tech{sum} scope to @var[id].
To prevent clashes between @tech{sums} and @tech{products} with the same
name, @tech{sum} bindings are defined in their own namespace. This form adds
a scope to @var[id] that represents the @tech{sum} namespace.
Example:
@example[
(data Either (Left Right))
(eval:error (Either? Left))
((sum Either?) Left)
(eval:error ((sum Either?) Either))
((sum Either?) (sum Either))
]
}
@defproc[(data-less-than? [Π1 product?] [Π2 product?]) boolean?]{
Returns @racket[#t] if the arguments are in the defined order.
Examples:
@example[
(data ABC (A B C))
(values (data-less-than? A C) (data-less-than? C A))
]
@example[
(data XYZ (X Y Z))
(sort (list Z Y X) data-less-than?)
]
}
@defproc[(sum? [v any/c]) boolean?]{
Returns @racket[#t] if @var[v] is a @tech{sum}.
}
@defproc[(product? [v any/c]) boolean?]{
Returns @racket[#t] if @var[v] is a @tech{constructor}.
}
@defproc[(instance? [v any/c]) boolean?]{
Returns @racket[#t] if @var[v] is an @tech{instance}.
}
@; -----------------------------------------------------------------------------
@subsection[#:tag "ref:functions"]{Functions}
@deftogether[(
@defform[(φ patt fun-directive ... body ...+)]
@defform/subs[
#:literals (quasiquote unquote quote void)
(phi patt fun-directive ... body ...+)
[(patt literal
wildcard-id
variable-id
product-id
(product-id patt ...)
(product-id patt ... . patt)
reference-id
(patt #:if condition-expr)
(patt #:as alias-patt)
regexp
(regexp patt ...+)
(regexp patt ... . patt)
symbol
(patt ...)
(patt ... . patt)
(struct-id ([field patt] ...))
(struct-id patt ...)
(quasiquote #,(var qfp))
(void)
#,(racketparenfont "#(" (var patt) ")")
#,(racketparenfont "#&" (var patt))
#,(racketparenfont "#hash([" (var key) " . " (var patt) "] ...)"))
(literal boolean
character
number
string
bytes
(quote #,(var datum)))
(qfp literal
id
()
(qfp . qfp)
(unquote patt))
(fun-directive (code:line #:if condition-expr)
(code:line #:as alias-patt)
(code:line #:with consequent-patt premise-expr))]
])]{
Creates a @tech{function} of one argument with one clause.
If @racket[#:as] @var[alias-patt]s are specified, they must all match the
original input for the overall match to succeed.
Optional @racket[#:if] @var[condition-expr]s specify that the pattern should
only match if the @var[condition-expr]s produce true values.
@var[condition-expr] is in the scope of all of the variables bound in
@var[patt] and any preceding @racket[#:as] directives.
Example:
@example[
(data SZ (S Z))
(let ([f (function
[(S x y) #:if (not x) #:if (not y) 0]
[(S x y) #:if (not (and x y)) (or x y)]
[(S x y) #:if x #:if y (+ x y)])])
(map f (list (S 1 2) (S #f 2) (S 1 #f) (S #f #f))))
]
An optional @racket[#:with] @var[consequent-patt] @var[premise-expr]
evaluates the @var[premise-expr] in the context of all the variables of
@var[patt] and the @var[alias-patt]s, if any. If the result matches
@var[consequent-patt], the pattern's variables are added to the environment
of subsequent side conditions. If the @racket[#:with] match fails, the
overall match also fails.
Multiple @racket[#:with] directives are evaluated independently from each
other.
Example:
@example[
((φ (#rx"^([^ ]+) ([^ ]+) HTTP/([^\r\n]+)" method uri version)
#:with #rx"^(?:GET|PUT|POST)$" method
#:with (#rx"^(.+)\\?(.+)$" path params) uri
#:with #rx"^[0-9]\\.[0-9]$" version
(list method path params version))
"GET /r/s?q=123&p=4 HTTP/1.0\r\n\r\n")
]
A @var[patt] has one of the following forms:
@specsubform[literal]{
A Racket literal value: @racket[#t], @racket[#f], @var[character],
@var[number], @var[string], @var[bytes], or @tt{(quote @var[datum])}.
Matches an @racket[equal?] constant.
Example:
@example[
((φ "one" 1) "one")
]
}
@specsubform[wildcard-id]{
An identifier whose name begins with an underscore ``@racketid[_]''.
Matches anything, without binding any identifiers.
Example:
@example[
((φ _ 1) 0)
(eval:error ((φ __x __x) 0))
]
}
@specsubform[variable-id]{
An identifier whose name begins with a
@racketlink[char-lower-case?]{lowercase} character.
Matches anything, and binds the identifier to the matching value in the
@var[body]s. If a variable binding is used multiple times within a
pattern, the corresponding matches must be the same according to
@racket[match-equality-test].
Example:
@example[
((φ x x) 1)
((φ (S x x) x) (S 2 2))
(eval:error ((φ (S x x) x) (S 3 4)))
]
}
@specsubform[product-id]{
Matches a @tech{constructor} named @var[product-id].
Example:
@example[
((φ S 1) S)
]
}
@defsubform*[
#:kind " "
#:link-target? #f
#:id [product-id (var product-id)]
[(product-id patt ...)
(product-id patt ... . patt)]
]{
Matches an @tech{instance} of the @tech{product} bound to @var[product-id]
with @tech{fields} that match @var[patt]s.
Example:
@example[
((φ (S x . xs) (list x xs)) (S 1 2 3))
]
}
@specsubform[reference-id]{
A @rtech{bound} identifier that is not a @var[wildcard-id],
@var[variable-id], or @var[constructor-id].
Matches the bound value.
Example:
@example[
((φ + 'Plus) +)
(eval:error ((φ + 'Plus) -))
]
}
@specsubform[(patt #:if condition-expr)]{
Matches @var[patt] if @var[condition-expr] produces a true value.
@var[cond-expr] is in the scope of all of the variables bound in
@var[patt].
Example:
@example[
((φ (n #:if (> n 0)) '+++) 5)
(eval:error ((φ (n #:if (> n 0)) '+++) -3))
]
}
@specsubform[(patt #:as alias-patt)]{
Matches @var[patt] if @var[alias-patt] also matches the same value.
Example:
@example[
((φ ((S x) #:as y) (list x y)) (S 1))
]
}
@defsubform*[
#:kind " "
#:link-target? #f
#:id [regexp (var regexp)]
[regexp
(regexp patt ...+)
(regexp patt ... . patt)]
]{
Matches @var[regexp] (a @rtech{regexp value} or byte-@rtech{regexp-value})
to a portion of its argument (a string, byte string, path, or input port)
with @racket[regexp-match].
Example:
@example[
(values
((φ #rx"x+y+" 1) "--xxyy++")
((φ #rx"a+b+" 2) (open-input-string "--aabb++")))
]
If any @var[patt]s are given, they are matched against the results. If one
or more capturing groups is present, the initial ``whole-match'' element
of the result list is dropped before attempting to match @var[patt]s.
Example:
@example[
(values
((φ (#rx"x+y+" xy) xy) "--xxyy++")
((φ (#rx"(a+)(b+)" as bs) (list as bs)) "--aabb++"))
(eval:error ((φ (#rx"(a+)(b+)" as bs cs) 'OK) "--aabb++"))
]
}
@specsubform[symbol]{
An unquoted datum literal that is not a @var[wildcard-id],
@var[variable-id], or @var[product-id].
Matches a symbol.
Example:
@example[
((φ $ 1) '$)
(eval:error ((φ $ 1) $))
]
}
@defsubform*[
#:kind " "
#:link-target? #f
#:id [patt (var patt)]
[(patt ...)
(patt ... . patt)]
]{
Matches @var[patt]s against the elements of a list.
Example:
@example[
((φ (a b c) (+ a b c)) '(1 2 3))
]
If the pattern contains a delimited @racketparenfont{.}, the final
@var[patt] is matched against the argument's tail.
Example:
@example[
((φ (a . b) (list a b)) '(1))
]
}
@defsubform*[
#:kind " "
#:link-target? #f
#:id [struct-id (var struct-id)]
[(struct-id ([field patt] ...))
(struct-id patt ..)]
]{
Matches an instance of a structure type named @var[struct-id], where each
field in the instance matches the corresponding @var[patt].
Example:
@example[
(struct F (a b c))
((φ (F x y z) (+ x y z)) (F 1 2 3))
]
If @var[field]s are present, any field of @var[struct-id] may be omitted,
and such fields can occur in any order.
Example:
@example[
(struct tree (val left right))
((φ (tree [val a]
[left (tree [right #f] [val b] [left #f])]
[right #f])
(list a b))
(tree 0 (tree 1 #f #f) #f))
((φ (tree a (tree b #f #f) #f) (list a b))
(tree 0 (tree 1 #f #f) #f))
]
}
@specsubform[
#:literals (quasiquote)
(quasiquote #,(var qfp))
]{
Introduces a @deftech{quasiquoted function pattern}, wherein all
identifiers match symbols and @racket[unquote] escapes back to normal
patterns.
Example:
@example[
((φ `(x y . ,(S a b)) (+ a b))
(list* 'x 'y (S 1 2)))
]
}
@specsubform[
#:literals (void)
(void)
]{
Matches a @seclink["void" #:doc '(lib
"scribblings/reference/reference.scrbl")]{void} value.
}
@specsubform[#,(racketparenfont "#(" (var patt) " ...)")]{
Matches @var[patt]s against the elements of a @rtech{vector}.
Example:
@example[
((φ #(a b c) (+ a b c)) (vector 1 2 3))
]
}
@specsubform[#,(racketparenfont "#&" (var patt))]{
Matches @var[patt] against the element of a @rtech{box}.
Example:
@example[
((φ #&x x) (box 1))
]
}
@specsubform[#,(racketparenfont "#hash([" (var key) " . " (var patt) "] ...)")]{
Matches against a @rtech{hash table}'s key-value pairs, where @var[key] is
a bare identifier or a @var[literal]. Any key-value pair of the hash table
may be omitted, and such pairs can occur in any order.
Example:
@example[
((φ #hash([x . a] ["y" . b]) (list a b))
(hash "y" 1 #t 2 'x 3))
]
}
}
@defform[(function [patt fun-directive ... body ...+] ...+)]{
Creates a @tech{function} of one argument with at least one clause. When
multiple clauses are given, they are attempted in the order specified.
Example:
@example[
(define fib
(function [n #:if (< n 2) 1]
[n (+ (fib (- n 1))
(fib (- n 2)))]))
(map fib '(0 1 2 3 4 5 6))
]
}
@deftogether[(
@defform[(φ* formals fun-directive ... body ...+)]
@defform/subs[
(phi* formals fun-directive ... body ...+)
[(formals (patt ...)
(patt ...+ . rest-patt)
rest-patt)]
])]{
Creates a @tech{function} of any number of arguments with one clause. The
@var[formals] determine the number of arguments.
A @var[formals] has one of the following forms:
@specsubform[(patt ...)]{
The function accepts as many argument values as the number of @var[patt]s.
Each @var[patt] is matched against an argument value by position.
Example:
@example[
(define fact
(function* [(n) (fact n 1)]
[(0 a) a]
[(n a) (fact (- n 1) (* a n))]))
(map fact '(0 1 2 3 4 5 6))
]
}
@specsubform[(patt ...+ . rest-patt)]{
The function accepts at least as many arguments as the number of
@var[patt]s. When the function is applied, the @var[patt]s are matched
against argument values by position, and all leftover arguments are placed
into a list that is matched against @var[rest-patt].
Example:
@example[
((function* [(x y . zs) (list x y zs)]) 1 2 3 4)
]
}
@specsubform[rest-patt]{
The function accepts any number of arguments and places them into a list
that is matched against @var[rest-patt].
Example:
@example[
((function* [xs (reverse xs)]) 1 2 3 4)
]
}
}
@defform[(function* [formals fun-directive ... body ...+] ...+)]{
Creates a @tech{function} of any number of arguments with one or more
clauses. When multiple clauses are given, they are attempted in the order
specified.
}
@defproc[(function? [v any/c]) boolean?]{
Returns @racket[#t] if @var[v] is a @tech{function}.
}
@; -----------------------------------------------------------------------------
@subsection[#:tag "ref:macros"]{Macros}
@deftogether[(
@defform[(μ mac-patt mac-directive ... body ...+)]
@defform/subs[
#:literals (void quasiquote unquote)
(mu mac-patt mac-directive ... body ...+)
[(mac-patt literal
wildcard-id
variable-id
id-literal
(mac-patt #:if condition-expr)
(mac-patt #:as alias-mac-patt)
(struct-id mac-patt ...)
(quasiquote #,(var qmp))
(mac-patt ...)
(mac-patt ...+ . mac-patt)
(mac-patt ooo . mac-patt))
(qmp (unquote mac-patt)
(qmp . qmp)
datum)
(ooo ...
...+)
(mac-directive (code:line #:with consequent-mac-patt premise-expr)
(code:line #:if condition-expr)
(code:line #:as alias-mac-patt))]
])]{
Creates a @tech{macro} of one argument with one clause.
A @var[mac-patt] is a @var[literal] or @var[wildcard-id] as defined for
@racket[φ], or one of the following forms:
@specsubform[variable-id]{
An identifier whose name begins with a
@racketlink[char-lower-case?]{lowercase} character.
Matches anything, and binds the pattern variable to the matching sub-term
in the @var[body]s. If the identifier is of the form
@var[id:syntax-class-id], it is an @tech[#:doc '(lib
"syntax/scribblings/syntax.scrbl")]{annotated pattern variable} and only
matches forms described by the @stech{syntax class} bound to
@var[syntax-class-id]. Otherwise, it matches anything.
Example:
@example[
(define-syntax m (μ x:id (identifier? #'x)))
(m a)
(eval:error (m 3))
]
}
@specsubform[id-literal]{
An identifier that is not a @var[wildcard-id] or @var[variable-id].
Matches an identifier literal.
Example:
@example[
(define-syntax m (μ ++ "plus plus"))
(m ++)
(eval:error (m --))
]
}
@specsubform[(mac-patt #:if condition-expr)]{
First matches @var[mac-patt], then evaluates the @var[condition-expr] in
the context of all previous variable bindings. If the value is
@racket[#f], the match fails.
Example:
@example[
(define-syntax m (μ (x #:if (number? (var x))) (+ x 2)))
(m 1)
(eval:error (m #f))
]
}
@specsubform[(mac-patt #:as alias-mac-patt)]{
First matches @var[mac-patt], then matches @var[alias-mac-patt] against
the same argument. If either pattern fails, the match fails.
Example:
@example[
(let-syntax ([calc (μ ((x + y) #:as sum)
(append 'sum `(= ,(+ x y))))])
(calc (1 + 2)))
]
}
@specsubform[(struct-id mac-patt ...)]{
Matches a sequence of terms, where the first element @var[struct-id] names
a structure type and subsequent elements match the corresponding
@var[mac-patt].
Example:
@example[
(struct F (a b c))
(define-syntax m (μ (F x y z) (+ x y z)))
(m (F 1 2 3))
]
}
@specsubform[
#:literals (quasiquote)
(quasiquote #,(var qmp))
]{
Introduces a @deftech{quasiquoted macro pattern}, in which identifiers
match symbols and @racket[unquote] escapes back to normal macro patterns.
Example:
@example[
(define-syntax m (μ `(x ,y) y))
(m (x #t))
(eval:error (m (z #t)))
]
}
@specsubform[(mac-patt ...)]{
Matches a parenthesized sequence of @var[mac-patt]s.
Example:
@example[
(define-syntax swap (μ (a b) (b a)))
(swap (0 S))
(instance? (swap (0 S)))
]
}
@specsubform[(mac-patt ...+ . mac-patt)]{
Matches a term with a list head and a tail separated by a delimited
@racketparenfont{.}.
Example:
@example[
(define-syntax m (μ (x y . z) (list x y z)))
(m (1 2 . 3))
]
}
@specsubform[(head-mac-patt ooo . tail-mac-pat)]{
Matches any term that can be decomposed into a list head matching some
number of repetitions of @var[head-mac-patt] followed by a list tail
matching @var[tail-mac-patt].
Example:
@example[
(define-syntax m
(macro* [(x ... (y ...) z ...+)
(list* x ... y ... z ...)]))
(values
(m 1 2 (3 4) 5 6)
(m (3 4) 5 6))
(eval:error (m 1 2 (3 4)))
]
}
The following pattern directives may appear any number of times in a macro
clause:
@specsubform[(code:line #:with mac-patt expr)]{
Evaluates @var[expr] in the context of all pattern bindings and matches
the result against @var[mac-patt]. The @var[expr] is implicitly
@racket[quasisyntax]ed, so @var[unsyntax] and @var[unsyntax-splicing]
escape to an expression within the transformer environment.
Example:
@example[#:escape UNSYNTAX
(let-syntax ([m (macro
[x #:with (a) #,(list 10)
#:with b 1
(+ x a b)])])
(m 100))
]
}
@specsubform[(code:line #:if condition-expr)]{
Evaluates the @var[condition-expr] in the context of all previous variable
bindings. If the value is @racket[#f], the match fails.
Example:
@example[#:escape UNSYNTAX
(define-syntax m-fib
(macro [n:nat #:if (< (var n) 2) 1]
[n:nat (+ (m-fib #,(- (var n) 1))
(m-fib #,(- (var n) 2)))]))
(values
(m-fib 0) (m-fib 1) (m-fib 2)
(m-fib 3) (m-fib 4) (m-fib 5) (m-fib 6))
(eval:error (let ([a 7]) (m-fib a)))
]
}
@specsubform[(code:line #:as alias-mac-patt)]{
Matches the original argument list against @var[alias-mac-patt].
Example:
@example[
(let-syntax ([calc (μ* (x + y) #:as sum
(append 'sum `(= ,(+ x y))))])
(calc 1 + 2))
]
}
}
@defform[(macro [mac-patt mac-directive ... body ...+] ...+)]{
Creates a @tech{macro} of one argument with one or more clauses. When
multiple clauses are given, they are attempted in the order specified.
}
@deftogether[(
@defform[(μ* mac-formals mac-directive ... body ...+)]
@defform/subs[
(mu* mac-formals mac-directive ... body ...+)
[(mac-formals (mac-patt ...)
(mac-patt ...+ . rest-mac-patt)
rest-mac-patt)]
])]{
Creates a @tech{macro} with any number of arguments and one clause. The
@var[mac-formals] determine the number of arguments in the same way as for
@racket[φ*], except with @var[mac-patt]s instead of @var[patt]s.
}
@defform[(macro* [mac-formals mac-directive ... body ...+] ...+)]{
Creates a @tech{macro} with any number of arguments and at least one clause.
When multiple clauses are given, they are attempted in the order specified.
}
@defform[(var id)]{
Returns the value bound to @var[id] in the transformer environment.
}
@; @section{Experimental Features}
@; =============================================================================
@bibliography[
@; @bib-entry[
@; #:key "Krishnamurthi2001"
@; #:title "Linguistic Reuse"
@; #:author "Krishnamurthi, Sriram"
@; #:location "PhD dissertation, Rice University"
@; #:date "2001"
@; ]
@bib-entry[
#:key "Taha2004"
#:title "A gentle introduction to multi-stage programming"
#:author "Taha, Walid"
#:location @list{In @emph{Domain-Specific Program Generation} (pp 30-50). Springer, Berlin, Heidelberg, 2004}
]
]
| true |
c8c1226e18ce6333969a2caa85f0d3737a6bc307 | e872962b1fb9b3c4b78e739e603e878bd29bde7c | /libgit2/include/annotated_commit.rkt | cfa0c3202c7d3c227a516c0ce20c9a1e6786be0e | [
"MIT"
]
| permissive | LiberalArtist/libgit2 | f0e266a85e205df30f6fab1c7876a6e3d85e9ba6 | af2670e94f8fa9b74aab98590c40bbd282fa0292 | refs/heads/main | 2023-08-06T23:40:18.395064 | 2023-07-08T19:23:25 | 2023-07-08T19:23:25 | 165,514,201 | 0 | 0 | MIT | 2019-01-13T14:21:34 | 2019-01-13T14:21:34 | null | UTF-8 | Racket | false | false | 1,083 | rkt | annotated_commit.rkt | #lang racket
(require ffi/unsafe
(submod "oid.rkt" private)
(only-in "types.rkt"
_git_repository
_git_annotated_commit
_git_reference)
"../private/base.rkt")
(provide (all-defined-out))
(define-libgit2/dealloc git_annotated_commit_free
(_fun _git_annotated_commit -> _void))
(define-libgit2/alloc git_annotated_commit_from_fetchhead
(_fun _git_annotated_commit _git_repository _string _string _git_oid-pointer -> _int)
git_annotated_commit_free)
(define-libgit2/alloc git_annotated_commit_from_ref
(_fun _git_annotated_commit _git_repository _git_reference -> _int)
git_annotated_commit_free)
(define-libgit2/alloc git_annotated_commit_from_revspec
(_fun _git_annotated_commit _git_repository _string -> _int)
git_annotated_commit_free)
(define-libgit2 git_annotated_commit_id
(_fun _git_annotated_commit -> _git_oid-pointer))
(define-libgit2/alloc git_annotated_commit_lookup
(_fun _git_annotated_commit _git_repository _git_oid-pointer -> _int)
git_annotated_commit_free)
| false |
e954138be7a3738b479bd25849c59ace9e9343e6 | b0c07ea2a04ceaa1e988d4a0a61323cda5c43e31 | /www/notes/agreement/primitives.rkt | d000066232c2807560e976fbaa3b39ce9fbc5c98 | [
"AFL-3.0"
]
| permissive | cmsc430/www | effa48f2e69fb1fd78910227778a1eb0078e0161 | 82864f846a7f8f6645821e237de42fac94dff157 | refs/heads/main | 2023-09-03T17:40:58.733672 | 2023-08-28T15:26:33 | 2023-08-28T15:26:33 | 183,064,322 | 39 | 30 | null | 2023-08-28T15:49:59 | 2019-04-23T17:30:12 | Racket | UTF-8 | Racket | false | false | 341 | rkt | primitives.rkt | #lang racket
(provide (all-defined-out))
(define (get-int)
(let ((in (string->number (read-line (current-input-port) 'any))))
(if (integer? in)
in
(error "error"))))
(define get-int-asm
`((mov r15 rsp)
; align rsp to safest 16-byte aligned spot
(and rsp -16)
(call get_int)
(mov rsp r15)))
| false |
1d21276956748d23787492641a0ffb092de318aa | 18c09f49ee1b6670426be9b0d10b6fb24f1475e4 | /Task/Matrix-multiplication/Racket/matrix-multiplication-1.rkt | 9944c7e32a7b6ccf9774285f3e3d459637bac102 | []
| no_license | hitme/RosettaCodeData | 579f07fe898b6642414281cf8567bac01f6098df | 1f1ad4942732d2b45e67dd9264c3cc8924a72d78 | refs/heads/master | 2021-01-13T04:37:54.198047 | 2013-04-12T23:18:05 | 2013-04-12T23:18:05 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 115 | rkt | matrix-multiplication-1.rkt | (define (m-mult m1 m2)
(for/list ([r m1])
(for/list ([c (apply map list m2)])
(apply + (map * r c)))))
| false |
e20fe8105df99d903f919197c8f22795b2a2996a | 3e9f044c5014959ce0e915fe1177d19f93d238ed | /racket/com-spacetimecat/edit/gui/markup-view.rkt | bc1cec674eb51338379ff3325b2a8e683f61442b | [
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"Apache-2.0",
"LicenseRef-scancode-public-domain",
"CC0-1.0",
"BSD-2-Clause"
]
| permissive | edom/work | 5e15c311dd49eb55fafbff3455cae505fa51643a | df55868caa436efc631e145a43e833220b8da1d0 | refs/heads/master | 2022-10-10T22:25:11.652701 | 2020-02-26T19:42:08 | 2020-02-26T19:44:58 | 138,504,284 | 0 | 1 | NOASSERTION | 2022-10-06T01:38:07 | 2018-06-24T18:03:16 | TeX | UTF-8 | Racket | false | false | 1,857 | rkt | markup-view.rkt | #lang s-exp "lang.rkt"
(require
(only-in "markup.rkt" markup?)
(prefix-in m: "markup.rkt")
(prefix-in mi: "markup-interpret.rkt")
"box.rkt"
)
(provide
markup-canvas%
)
(define markup-canvas% (class canvas%
;; Do not use 'transparent.
;; The text somehow gets drawn twice and overlaps.
(super-new [style '(no-focus)])
(init-field [markup (m:empty)])
(inherit get-dc
min-width
min-height)
(define (recompute-min-size)
(define box (mi:interpret/measure (get-dc) markup))
(define (ceil x) (inexact->exact (ceiling x)))
(min-width (ceil (Box-w box)))
(min-height (ceil (Box-h box))))
(define/public (get-markup) markup)
(define/public (set-markup m)
(unless (m:markup? m) (raise-argument-error 'set-markup "markup?" m))
(set! markup m)
(recompute-min-size)
(send this refresh))
(recompute-min-size)
(define/override (on-paint)
(super on-paint)
(mi:interpret/render (get-dc) markup))
))
;; Test.
#;(begin
(provide main)
(define (main)
(define frame (new test-frame%))
(define markup
(m:vflow (list
(m:hflow (list
(m:string "This is ")
(m:bold (m:string "bold"))
(m:string ".")
))
(m:hflow (list
(m:string "This is also ")
(m:bold (m:string "bold"))
(m:string ".")
))
(m:hflow (list
(m:string "This is ")
(m:bold (m:string "bold"))
(m:string " too.")
))
)))
(define view (new markup-canvas% [parent frame] [markup markup]))
(void)))
| false |
b945ea9e28d840ac342399c7a92151606e523ef0 | 349f2831919b1c3b5019557fdae2b2bd907d0039 | /cameron/info.rkt | 4aafed69b91b742121dc5e99c231f21d3dd03bba | [
"BSD-3-Clause"
]
| permissive | Asosio/cameron | e48e933271ef78f9637487d043e37a5d6375c3de | 539a98816119d05409c270803232fef7be22dd22 | refs/heads/master | 2021-01-13T00:55:42.167033 | 2016-03-04T13:22:41 | 2016-03-04T13:22:41 | 48,999,146 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 89 | rkt | info.rkt | #lang info
(define name "cameron")
(define scribblings '(("scribble/cameron.scrbl" ())))
| false |
920d0202decb77703e1e5bc7560bad0907c4c92c | 88a45661d9224fa1ef8b37ad50b8c8c549e824a8 | /TodoApp/axio/axio-logger.rkt | 4cd211f86dfa9dd61e0d7ff2a3a8be570a931556 | [
"MIT"
]
| permissive | spdegabrielle/RacketCon2020 | 8c4be25f2aaeb79e9cc0961e54d5a7d0a727d678 | 310e0ab01d8c3e1546029720f6bb66e6d1a5fb1e | refs/heads/master | 2023-03-04T14:00:58.778104 | 2021-02-21T15:30:33 | 2021-02-21T15:30:33 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,132 | rkt | axio-logger.rkt | #lang racket/base
(require racket/contract
racket/match)
(provide axio-init-logger
axio-log-debug
axio-log-error
axio-log-fatal
axio-log-info
axio-log-receiver
axio-log-warning
axio-logger
axio-logger-from-symbol)
(define logger #f)
;; --------------------------------------------------------------------------------------------
;; Public Interface
;; --------------------------------------------------------------------------------------------
(define/contract (axio-init-logger level)
(-> symbol? any)
(set! logger (make-logger 'axio))
(axio-log-receiver
level
'axio
(λ (level message data topic)
(printf "level:~a topic:~a message:~a\n" level topic message)
(flush-output))))
(define/contract (axio-log-debug str [topic 'axio])
(->* (string?) (symbol?) any)
(log-message logger 'debug topic str #f #f))
(define/contract (axio-log-error str [topic 'axio])
(->* (string?) (symbol?) any)
(log-message logger 'error topic str #f #f))
(define/contract (axio-log-fatal str [topic 'axio])
(->* (string?) (symbol?) any)
(log-message logger 'fatal topic str #f #f))
(define/contract (axio-log-info str [topic 'axio])
(->* (string?) (symbol?) any)
(log-message logger 'info topic str #f #f))
(define/contract (axio-log-receiver level topic proc)
(-> symbol? symbol? (-> symbol? string? any/c symbol? any) any)
(define log-receiver (make-log-receiver logger level topic))
(void
(thread
(λ ()
(let loop ()
(match (sync log-receiver)
[(vector level message data topic) (proc level message data topic)])
(loop))))))
(define/contract (axio-log-warning str [topic 'axio])
(->* (string?) (symbol?) any)
(log-message logger 'warning topic str #f #f))
(define/contract (axio-logger)
(-> logger?)
logger)
(define/contract (axio-logger-from-symbol sym)
(-> symbol? any)
(match sym
[ 'debug axio-log-debug ]
[ 'error axio-log-error ]
[ 'fatal axio-log-fatal ]
[ 'info axio-log-info ]
[ 'warning axio-log-warning ]))
| false |
228b89f5acad3329842e39f22cd0cc047db8edd8 | ea01d04297a6f1b33c99c44b6c3d52445c52dc50 | /diagrama-doc/diagrama/scribblings/reference.scrbl | 73b494ab054fbec012767d53c0e8ce1ca4f70f54 | [
"MIT"
]
| permissive | dvanhorn/diagrama | 8960392adf1bfa83dc8e607e37bb9bb48b4c63bd | 291f244843d7226df4b7cb763bc3d6b1e98af71b | refs/heads/master | 2023-01-30T16:35:52.625283 | 2020-03-09T22:04:23 | 2020-03-09T22:04:23 | 322,027,858 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 15,979 | scrbl | reference.scrbl | #lang scribble/manual
@title{Diagrama API Reference}
@(require "base.rkt")
@defmodule[diagrama #:use-sources (diagrama)]
@bold{Warning:} The API presented here is unstable, and may change without warning.
@defproc[(diagram? [it any/c])
boolean?]{
Is @racket[it] a Diagram. Diagrams are computations that
draw, well, diagrams. Diagrams have a state which consists
of a current drawing location, a notion of units, a
line-width, and line-color.
Diagrams are @racket[pict-convertible?]. When diagrams are
drawn the whole image is shifted such that the minimum x and
y coordinate are shifted to the origin. When diagrams are
converted to @racket[pict?]s the starting coordinates are
always (@racket[0],@racket[0]).
}
@section{Basic diagram constructors}
@defthing[nothing diagram?]{
An empty diagram.
}
@defproc[(img [p pict-convertible?]
[align (or/c 'lt 'ct 'rt 'lc 'cc 'rc 'lb 'cb 'rb) 'cc])
diagram?]{
Convert this @racket[p] into a diagram which just draws @racket[p].
The part of @racket[p] designated by @racket[align] controls
which part of @racket[p] is placed at the current location. For
example @racket['cc] centers it.
}
@defproc[(path [path (is-a?/c dc-path%)]
[fill-style (or/c 'odd-even 'winding) 'odd-even])
diagram?]{
Draw the given path. The path is interpreted in terms
of the current location and units, and the current location
after drawing the path is the location of the last
point in the paths. The path is not mutated.
The @racket[fill-style] is the same as the same argument
from @method[dc<%> draw-path].
@examples[#:eval diag
(define unit-line-right
(let ()
(define p (new dc-path%))
(send p move-to 0 0)
(send p line-to 1 0)
(path p)))
unit-line-right
(after (move-to 3 0) unit-line-right)
(after (units 36) (move-to 3 0) unit-line-right)
(after (units 36) (move-to 3 0) (color "red") unit-line-right)]
}
@defproc[(line-to [x real?] [y real?] [#:h-first h-fit any/c #t])
diagram?]{
Creates a diagram which draws a line from the current
location to (@racket[x],@racket[y]). The line moves only
horizontally and vertically. If @racket[h-first] is
not @racket[#f] it moves horizontally then vertically, otherwise
it does the reverse.
@examples[#:eval diag
(line-to 3 2)]
}
@deftogether[(@defproc[(line-left [d real?]) diagram?]
@defproc[(line-right [d real?]) diagram?]
@defproc[(line-up [d real?]) diagram?]
@defproc[(line-down [d real?]) diagram?])]{
Create a diagram which draws a line from the current location
@racket[d] away in the given direction.
@examples[#:eval diag
(line-right 5)
(line-up 5)]
}
@defproc[(move-to [x real?] [y real?]) diagram?]{
Makes an empty diagram which moves the current drawing
location to (@racket[x],@racket[y]), with
(@racket[0],@racket[0]) being in the upper left.
@examples[#:eval diag
(after
(move-to 3 3)
(line-right 5))]
}
@deftogether[(@defproc[(move-left [d real?]) diagram?]
@defproc[(move-right [d real?]) diagram?]
@defproc[(move-up [d real?]) diagram?]
@defproc[(move-down [d real?]) diagram?])]{
Makes an empty diagram which moves the current location
by @racket[d] in the corresponding direction.
}
@defproc[(tag-location [name any/c]
[x real? #f]
[y real? #f])
diagram?]{
Make an empty diagram that names ta location @racket[name].
If @racket[x] and @racket[y] given that location is
named, otherwise the current location is names.
This will overwrite any existing locations which have a name @racket[equal?]
to @racket[name].
}
@defproc[(move-to-tag [name any/c]) diagram?]{
Move to the location with the given @racket[name]. Errors
if no location has that @racket[name].
}
@defproc[(line-to-tag [name any/c] [#:h-first h-fit any/c #t])
diagram?]{
Draw a line from the current location to the location with
the given @racket[name]. Errors if no location has that
@racket[name]. The line is drawn like @racket[line-to].
@examples[#:eval diag
(after
(tag-location 'here 3 3)
(move-to 0 0)
(line-to-tag 'here))]
}
@defproc[(line-between [start any/c] [end any/c] [#:h-first h-fit any/c #t]) diagram]{
Draw a line between the two named coordinates. See also
@racket[line-to-tag] and @racket[line-to].
@examples[#:eval diag
(after
(tag-location 'here 1 2)
(tag-location 'there 4 0)
(line-between 'here 'there))]
}
@defproc[(units [u positive?]) diagram?]{
Create an empty diagram that changes the current
size of the coordinate system to @racket[u]. The default
is @racket[12].
@examples[#:eval diag
(define l (line-right 1))
l
(after (units 36) l)]
}
@defproc[(color [c (or/c string? (is-a?/c color%))]) diagram?]{
Create an empty diagram that changes
the current line color.
@examples[#:eval diag
(after (units 36) (color "red")
(line-right 2))]
}
@defproc[(line-width [l (real-in 0 255)]) diagram?]{
Create an empty diagram that changes
the current line width.
}
@defproc[(label [t string?] [dir (or/c 'up 'down 'left 'right)])
diagram?]{
Add text to the diagram one unit in the given direction.
@examples[#:eval diag
(after
(units 24)
(save (label "Line" 'right))
(line-up 1)
(line-down 2))]
}
@defthing[unit-grid diagram?]{
Draws a grid over the current diagram with length/width of each
cell of unit length.
@examples[#:eval diag
(define l (line-right 3))
l
(after l unit-grid)
(after l (units 24) unit-grid)
(after (units 24) l unit-grid)
(after
(save l)
(move-down 1) (save l)
(move-down 1) (save l)
unit-grid)]
}
@section{Diagram composition}
@defproc[(after [d diagram?] ...) diagram?]{
Draw all of the @racket[d]s one after another.
@examples[#:eval diag
(after
(line-up 3)
(line-right 3)
(line-down 3)
(line-left 3))]
}
@defproc[(before [d1 diagram?] [d diagram?] ...) diagram?]{
Draw all of the @racket[d]s one after another, then
draw @racket[d1] at with initial state of the diagram.
@examples[#:eval diag
(after (img (disk 36 #:color "white"))
(line-right 3))
(before (img (disk 36 #:color "white"))
(line-right 3))]
}
@defproc[(save [d diagram?] ...) diagram?]{
Draw all of @racket[d] one after another,
then resort the current units and location
to what they were at the start of the @racket[save].
}
@defproc[(save/bounds [d diagram?] ...) diagram?]{
Like @racket[save] except the bounds of the diagram are are
restored after the @racket[d]s are draw. This allows for
drawing outside of the bounds of the resulting @racket[pict?].
}
@defproc[(split [d1 diagram?] [d2 diagram])
diagram?]{
Draw @racket[d1] and @racket[d2] with the current
state, and place a black dot at the current location. The
resulting state is the state from @racket[d2].
@examples[#:eval diag
(after
(line-right 3)
(split
(after (line-up 3) (line-right 3))
(after (line-down 3) (line-right 3)))
(line-down 3))]
}
@defproc[(*> [d1 diagram?] [d diagram?] ...) diagram?]{
Draw all of the diagrams in order, with each being drawn
with the initial state. The resulting state is that of the
last diagram.
@examples[#:eval diag
(after
(units 36)
(*> (line-up 1)
(line-down 1)
(line-left 1)
(line-right 1))
(line-down 1))]
}
@defproc[(<* [d1 diagram?] [d diagram?] ...) diagram?]{
Draw all of the diagrams in order, with each being drawn
with the initial state. The resulting state is that of the
first diagram.
@examples[#:eval diag
(after
(units 36)
(<* (line-up 1)
(line-down 1)
(line-left 1)
(line-right 1))
(line-right 1))]
}
@defproc[(start-at [#:ud ud (or/c 'up 'down)]
[#:lr lr (or/c 'left 'right)]
[d diagram?] ...)
diagram]{
Draw the diagrams in order, with each starting at the
location on the corner of the previous specified by
@racket[ud] and @racket[lr]. The first diagram
is drawn at the current location.
}
@deftogether[(@defform[(for/after (for-clauses ...) body-or-break ... body)]
@defform[(for*/after (for-clauses ...) body-or-break ... body)]
@defform[(for/*> (for-clauses ...) body-or-break ... body)]
@defform[(for*/*> (for-clauses ...) body-or-break ... body)]
@defform[(for/<* (for-clauses ...) body-or-break ... body)]
@defform[(for*/<* (for-clauses ...) body-or-break ... body)])]{
Your friendly neighborhood @racket[for] forms, for building
diagrams using @racket[after], @racket[*>], and @racket[<*].
}
@section{Reflecting on the drawing state}
There are several ways to directly inspect the current
drawing state. These are all fairly low level operations
that are most likely useful for making new combinators, or when
making @racket[pict?]'s that scale to the current unit size (for
example @racket[unit-grid] and @racket[start-at] are defined
with these).
@defproc[(with-loc
[builder (-> real? real? diagram?)])
diagram?]{
Build a diagram using the current (x,y) location.
}
@defproc[(with-bounds
[builder (-> real? real? real? real? diagram?)])
diagram?]{
Build a diagram given the current bounding box. See @racket[with-state]
for the order of arguments to @racket[builder].
}
@defproc[(with-color
[builder (-> (or/c string? (is-a?/c color%)) diagram?)])
diagram?]{
Build a diagram using the current color.
}
@defproc[(with-line-width
[builder (-> (real-in 0 255) diagram?)])
diagram?]{
Build a diagram using the current line width.
}
@defproc[(with-unit
[builder (-> real? diagram?)])
diagram?]{
Build a diagram given the current units.
@examples[#:eval diag
(define unit-circle
(with-unit (compose img circle)))
unit-circle
(after (units 24) unit-circle)
(scale
(after
(units 24)
(for*/fold ([p nothing])
([x (in-range 3)]
[y (in-range 3)])
(after p
(move-to x y)
unit-circle))
unit-grid)
2)]
}
@defproc[(with-location-of [tag any/c]
[builder (-> real? real? diagram?)])
diagram?]{
Build a diagram using the the given named location.
}
@section{Circuit Helpers}
@defmodule[diagrama/circuit #:use-sources (diagrama/circuit)]
@racketmodname[diagrama/circuit] has helpers for drawing
circuit diagrams. Note that it is easy to accidentally draw
lines on top of gates: @racket[before] is designed to help
with this.
@deftogether[(@defproc[(or-gate
[#:in1 n1 any/c #f]
[#:in2 n2 any/c #f]
[#:in3 n3 any/c #f]
[#:out out any/c #f]
[#:tag-in1 tag1 any/c #f]
[#:tag-in2 tag2 any/c #f]
[#:tag-in3 tag3 any/c #f]
[#:tag-out tag4 any/c #f])
diagram?]
@defproc[(and-gate
[#:in1 n1 any/c #f]
[#:in2 n2 any/c #f]
[#:in3 n3 any/c #f]
[#:out out any/c #f]
[#:tag-in1 tag1 any/c #f]
[#:tag-in2 tag2 any/c #f]
[#:tag-in3 tag3 any/c #f]
[#:tag-out tag4 any/c #f])
diagram?]
@defproc[(buffer
[#:in2 n2 any/c #f]
[#:out out any/c #f]
[#:tag-in2 tag2 any/c #f]
[#:tag-out tag4 any/c #f])
diagram?]
@defproc[(register
[#:in2 n2 any/c #f]
[#:out out any/c #f]
[#:tag-in2 tag2 any/c #f]
[#:tag-out tag4 any/c #f])
diagram?])]{
Make a diagram that draws the given gate, each gate facing
to the right. @racket[or-gate] and @racket[and-gate] are
three units square, and designed to take in up to three
input wires. @racket[buffer] and @racket[register] are
roughly the same size, but are designed to take only one
input. If @racket[n1], @racket[n2], or @racket[n3] are not
@racket[#f], then the upper, middle, or lower input
(respectively) are negated. @racket[out] does the same for
the output. If @racket[tag1], @racket[tag2] or @racket[tag3]
a wire is drawn for those inputs, and its endpoint is named
by the given tag. @racket[tag4] does the same for the
output.
The drawn gate is centered at the current location.
@examples[#:eval diag
(define layer-1-x 6)
(define layer-2-x 3)
(define input-1 (tag-location 'input-1 0 0))
(define input-2 (tag-location 'input-2 0 2))
(define top-gate
(after
(move-down 1) (move-right layer-1-x)
(and-gate #:out #t
#:tag-out 'and-out
#:tag-in1 'and-A
#:tag-in3 'and-B)))
(define lower-gate
(after
(move-down 5) (move-right layer-1-x)
(or-gate #:tag-out 'or-out
#:tag-in1 'or-A
#:tag-in3 'or-B)))
(define last-gate
(after
(move-down 1) (move-right layer-2-x)
(and-gate #:tag-in1 'and-in
#:tag-in3 'or-in
#:tag-out 'result)))
(define (connect-input input g1 g2 split-point)
(after
(move-to-tag input)
(line-right split-point)
(split
(line-to-tag g1)
(line-to-tag g2 #:h-first #f))))
(define xor
(after
input-1 input-2
(move-to-tag 'input-1)
(save top-gate) (save lower-gate)
(move-to-tag 'and-out) last-gate
(connect-input 'input-1 'and-A 'or-A 3)
(connect-input 'input-2 'and-B 'or-B 2)
(line-between 'and-out 'and-in)
(line-between 'or-out 'or-in)
(move-to-tag 'result)
(line-right 1)))
(scale xor 2)
(scale (after xor unit-grid) 2)]
}
| false |
3e315d6d491b6d88856829733bbe08e6fc2343dc | c31f57f961c902b12c900ad16e5390eaf5c60427 | /data/programming_languages/scheme/table.rkt | f97e4d2e486fbbc21c1af2490c8c10a0345ed92a | []
| no_license | klgraham/deep-learning-with-pytorch | ccc7602d9412fb335fe1411ba31641b9311a4dba | 4373f1c8be8e091ea7d4afafc81dd7011ef5ca95 | refs/heads/master | 2022-10-24T01:48:46.160478 | 2017-03-13T20:07:03 | 2017-03-13T20:07:03 | 79,877,434 | 0 | 1 | null | 2022-10-02T20:42:36 | 2017-01-24T04:12:24 | C | UTF-8 | Racket | false | false | 11,263 | rkt | table.rkt | #lang scheme/base
;; Routine to build the LALR table
(require "grammar.rkt"
"lr0.rkt"
"lalr.rkt"
"parser-actions.rkt"
racket/contract
mzlib/list
mzlib/class)
(define (is-a-grammar%? x) (is-a? x grammar%))
(provide/contract
(build-table (-> is-a-grammar%? string? any/c
(vectorof (listof (cons/c (or/c term? non-term?) action?))))))
;; A parse-table is (vectorof (listof (cons/c gram-sym? action)))
;; A grouped-parse-table is (vectorof (listof (cons/c gram-sym? (listof action))))
;; make-parse-table : int -> parse-table
(define (make-parse-table num-states)
(make-vector num-states null))
;; table-add!: parse-table nat symbol action ->
(define (table-add! table state-index symbol val)
(vector-set! table state-index (cons (cons symbol val)
(vector-ref table state-index))))
;; group-table : parse-table -> grouped-parse-table
(define (group-table table)
(list->vector
(map
(lambda (state-entry)
(let ((ht (make-hash)))
(for-each
(lambda (gs/actions)
(let ((group (hash-ref ht (car gs/actions) (lambda () null))))
(unless (member (cdr gs/actions) group)
(hash-set! ht (car gs/actions) (cons (cdr gs/actions) group)))))
state-entry)
(hash-map ht cons)))
(vector->list table))))
;; table-map : (vectorof (listof (cons/c gram-sym? X))) (gram-sym? X -> Y) ->
;; (vectorof (listof (cons/c gram-sym? Y)))
(define (table-map f table)
(list->vector
(map
(lambda (state-entry)
(map
(lambda (gs/X)
(cons (car gs/X) (f (car gs/X) (cdr gs/X))))
state-entry))
(vector->list table))))
(define (bit-vector-for-each f bv)
(letrec ((for-each
(lambda (bv number)
(cond
((= 0 bv) (void))
((= 1 (bitwise-and 1 bv))
(f number)
(for-each (arithmetic-shift bv -1) (add1 number)))
(else (for-each (arithmetic-shift bv -1) (add1 number)))))))
(for-each bv 0)))
;; print-entry: symbol action output-port ->
;; prints the action a for lookahead sym to the given port
(define (print-entry sym a port)
(let ((s "\t~a\t\t\t\t\t~a\t~a\n"))
(cond
((shift? a)
(fprintf port s sym "shift" (shift-state a)))
((reduce? a)
(fprintf port s sym "reduce" (prod-index (reduce-prod a))))
((accept? a)
(fprintf port s sym "accept" ""))
((goto? a)
(fprintf port s sym "goto" (goto-state a))))))
;; count: ('a -> bool) * 'a list -> num
;; counts the number of elements in list that satisfy pred
(define (count pred list)
(cond
((null? list) 0)
((pred (car list)) (+ 1 (count pred (cdr list))))
(else (count pred (cdr list)))))
;; display-parser: LR0-automaton grouped-parse-table (listof prod?) output-port ->
;; Prints out the parser given by table.
(define (display-parser a grouped-table prods port)
(let* ((SR-conflicts 0)
(RR-conflicts 0))
(for-each
(lambda (prod)
(fprintf port
"~a\t~a\t=\t~a\n"
(prod-index prod)
(gram-sym-symbol (prod-lhs prod))
(map gram-sym-symbol (vector->list (prod-rhs prod)))))
prods)
(send a for-each-state
(lambda (state)
(fprintf port "State ~a\n" (kernel-index state))
(for-each (lambda (item)
(fprintf port "\t~a\n" (item->string item)))
(kernel-items state))
(newline port)
(for-each
(lambda (gs/action)
(let ((sym (gram-sym-symbol (car gs/action)))
(act (cdr gs/action)))
(cond
((null? act) (void))
((null? (cdr act))
(print-entry sym (car act) port))
(else
(fprintf port "begin conflict:\n")
(when (> (count reduce? act) 1)
(set! RR-conflicts (add1 RR-conflicts)))
(when (> (count shift? act) 0)
(set! SR-conflicts (add1 SR-conflicts)))
(map (lambda (x) (print-entry sym x port)) act)
(fprintf port "end conflict\n")))))
(vector-ref grouped-table (kernel-index state)))
(newline port)))
(when (> SR-conflicts 0)
(fprintf port "~a shift/reduce conflict~a\n"
SR-conflicts
(if (= SR-conflicts 1) "" "s")))
(when (> RR-conflicts 0)
(fprintf port "~a reduce/reduce conflict~a\n"
RR-conflicts
(if (= RR-conflicts 1) "" "s")))))
;; resolve-conflict : (listof action?) -> action? bool bool
(define (resolve-conflict actions)
(cond
((null? actions) (values (make-no-action) #f #f))
((null? (cdr actions))
(values (car actions) #f #f))
(else
(let ((SR-conflict? (> (count shift? actions) 0))
(RR-conflict? (> (count reduce? actions) 1)))
(let loop ((current-guess #f)
(rest actions))
(cond
((null? rest) (values current-guess SR-conflict? RR-conflict?))
((shift? (car rest)) (values (car rest) SR-conflict? RR-conflict?))
((not current-guess)
(loop (car rest) (cdr rest)))
((and (reduce? (car rest))
(< (prod-index (reduce-prod (car rest)))
(prod-index (reduce-prod current-guess))))
(loop (car rest) (cdr rest)))
((accept? (car rest))
(eprintf "accept/reduce or accept/shift conflicts. Check the grammar for useless cycles of productions\n")
(loop current-guess (cdr rest)))
(else (loop current-guess (cdr rest)))))))))
;; resolve-conflicts : grouped-parse-table bool -> parse-table
(define (resolve-conflicts grouped-table suppress)
(let* ((SR-conflicts 0)
(RR-conflicts 0)
(table (table-map
(lambda (gs actions)
(let-values (((action SR? RR?)
(resolve-conflict actions)))
(when SR?
(set! SR-conflicts (add1 SR-conflicts)))
(when RR?
(set! RR-conflicts (add1 RR-conflicts)))
action))
grouped-table)))
(unless suppress
(when (> SR-conflicts 0)
(eprintf "~a shift/reduce conflict~a\n"
SR-conflicts
(if (= SR-conflicts 1) "" "s")))
(when (> RR-conflicts 0)
(eprintf "~a reduce/reduce conflict~a\n"
RR-conflicts
(if (= RR-conflicts 1) "" "s"))))
table))
;; resolve-sr-conflict : (listof action) (union int #f) -> (listof action)
;; Resolves a single shift-reduce conflict, if precedences are in place.
(define (resolve-sr-conflict/prec actions shift-prec)
(let* ((shift (if (shift? (car actions))
(car actions)
(cadr actions)))
(reduce (if (shift? (car actions))
(cadr actions)
(car actions)))
(reduce-prec (prod-prec (reduce-prod reduce))))
(cond
((and shift-prec reduce-prec)
(cond
((< (prec-num shift-prec) (prec-num reduce-prec))
(list reduce))
((> (prec-num shift-prec) (prec-num reduce-prec))
(list shift))
((eq? 'left (prec-assoc shift-prec))
(list reduce))
((eq? 'right (prec-assoc shift-prec))
(list shift))
(else null)))
(else actions))))
;; resolve-prec-conflicts : parse-table -> grouped-parse-table
(define (resolve-prec-conflicts table)
(table-map
(lambda (gs actions)
(cond
((and (term? gs)
(= 2 (length actions))
(or (shift? (car actions))
(shift? (cadr actions))))
(resolve-sr-conflict/prec actions (term-prec gs)))
(else actions)))
(group-table table)))
;; build-table: grammar string bool -> parse-table
(define (build-table g file suppress)
(let* ((a (build-lr0-automaton g))
(term-vector (list->vector (send g get-terms)))
(end-terms (send g get-end-terms))
(table (make-parse-table (send a get-num-states)))
(get-lookahead (compute-LA a g))
(reduce-cache (make-hash)))
(for-each
(lambda (trans-key/state)
(let ((from-state-index (kernel-index (trans-key-st (car trans-key/state))))
(gs (trans-key-gs (car trans-key/state)))
(to-state (cdr trans-key/state)))
(table-add! table from-state-index gs
(cond
((non-term? gs)
(make-goto (kernel-index to-state)))
((member gs end-terms)
(make-accept))
(else
(make-shift
(kernel-index to-state)))))))
(send a get-transitions))
(send a for-each-state
(lambda (state)
(for-each
(lambda (item)
(let ((item-prod (item-prod item)))
(bit-vector-for-each
(lambda (term-index)
(unless (start-item? item)
(let ((r (hash-ref reduce-cache item-prod
(lambda ()
(let ((r (make-reduce item-prod)))
(hash-set! reduce-cache item-prod r)
r)))))
(table-add! table
(kernel-index state)
(vector-ref term-vector term-index)
r))))
(get-lookahead state item-prod))))
(append (hash-ref (send a get-epsilon-trans) state (lambda () null))
(filter (lambda (item)
(not (move-dot-right item)))
(kernel-items state))))))
(let ((grouped-table (resolve-prec-conflicts table)))
(unless (string=? file "")
(with-handlers [(exn:fail:filesystem?
(lambda (e)
(eprintf
"Cannot write debug output to file \"~a\": ~a\n"
file
(exn-message e))))]
(call-with-output-file file
(lambda (port)
(display-parser a grouped-table (send g get-prods) port))
#:exists 'truncate)))
(resolve-conflicts grouped-table suppress))))
| false |
7ab4f741325604e32309624f6b39ff73296a2abd | 56c17ee2a6d1698ea1fab0e094bbe789a246c54f | /2021/13.rktd | 188121bae200760b0cf14692d7027481fe808068 | [
"MIT"
]
| permissive | mbutterick/aoc-racket | 366f071600dfb59134abacbf1e6ca5f400ec8d4e | 14cae851fe7506b8552066fb746fa5589a6cc258 | refs/heads/master | 2022-08-07T10:28:39.784796 | 2022-07-24T01:42:43 | 2022-07-24T01:42:43 | 48,712,425 | 39 | 5 | null | 2017-01-07T07:47:43 | 2015-12-28T21:09:38 | Racket | UTF-8 | Racket | false | false | 7,026 | rktd | 13.rktd | 1118,85
1064,690
560,670
68,446
769,668
88,219
120,255
925,879
112,512
1064,652
1046,233
902,417
523,33
1012,280
1210,135
410,142
689,497
698,211
981,259
465,610
689,621
1093,887
114,728
790,809
139,59
798,257
390,457
482,281
701,190
840,283
320,723
498,504
256,397
100,115
401,92
796,780
239,729
755,539
736,870
676,567
484,560
405,511
187,387
356,155
42,659
182,508
256,374
572,320
738,207
328,80
70,528
1111,752
648,54
33,308
716,704
701,798
700,324
10,260
1076,401
554,533
592,885
269,575
492,528
646,837
1134,268
1290,619
442,248
549,519
908,647
402,280
1081,428
768,575
1277,525
472,121
985,635
912,374
512,499
708,807
1054,558
305,856
401,756
8,53
1044,256
607,581
156,840
756,331
771,609
276,456
1268,842
1123,387
155,526
1125,380
612,52
864,772
572,126
1084,597
666,397
574,169
33,481
1098,280
468,215
370,3
639,204
1230,466
512,684
705,161
738,126
355,376
1096,736
1166,476
1036,135
912,782
947,32
636,50
623,250
1257,215
416,672
989,74
1300,852
776,659
1196,838
1064,304
252,471
994,410
459,33
567,361
489,159
1240,528
58,506
944,339
788,0
319,857
644,215
787,33
1198,767
798,843
920,233
760,411
1300,626
52,311
812,558
378,227
226,437
386,444
169,291
308,172
698,618
514,231
761,235
157,774
798,684
902,29
428,37
698,52
405,383
1104,256
1058,784
299,518
617,332
346,498
1178,89
1290,275
1196,166
293,425
895,567
1034,662
596,56
687,250
534,255
623,698
1309,719
92,347
226,297
736,253
497,155
736,528
776,780
223,42
465,732
900,53
493,411
909,838
542,512
385,659
537,590
1228,80
420,462
761,519
879,852
1277,693
908,838
890,324
1092,383
691,862
602,378
416,224
296,598
666,215
234,347
902,142
1101,253
581,362
316,567
28,255
929,824
117,77
848,515
701,704
1136,233
485,680
1233,511
788,357
246,304
500,505
1144,63
738,320
964,620
623,413
26,495
58,390
82,590
930,311
239,578
748,784
873,518
385,879
311,242
1036,666
1230,641
1032,224
80,325
1233,383
1290,171
31,413
1076,493
402,838
731,690
977,522
92,36
144,476
520,365
428,396
1196,390
100,149
818,752
142,637
21,882
295,61
631,435
731,204
676,584
68,448
748,544
560,224
1,719
683,152
490,590
909,373
517,568
967,690
1015,450
1092,175
729,532
676,248
912,858
1180,0
174,233
73,586
403,292
325,635
308,474
733,511
38,787
278,222
562,36
485,603
296,822
428,149
433,494
1240,120
136,175
1240,366
1240,774
485,214
73,745
668,364
1071,119
185,514
882,268
544,614
540,838
139,773
1005,236
156,280
1290,584
813,155
209,826
773,572
715,852
11,700
562,350
209,701
293,33
117,301
1248,710
343,690
274,359
1146,646
930,666
189,162
161,383
485,291
912,558
252,784
1237,745
35,32
105,235
760,483
62,821
977,372
366,591
221,848
120,108
991,857
909,381
355,518
316,791
445,583
422,710
510,508
52,516
349,236
277,201
276,662
676,758
502,455
353,844
415,316
28,404
498,558
554,107
1101,701
935,873
865,701
1071,327
497,409
756,626
1272,555
1118,851
1073,280
385,463
954,827
1048,845
402,59
602,807
577,511
234,509
642,880
97,428
705,226
73,532
1179,33
74,87
226,361
256,484
1154,280
989,887
982,696
977,74
566,51
480,45
398,72
142,283
848,851
957,844
390,233
999,242
366,339
776,255
1096,830
845,162
403,826
1078,264
274,666
622,506
70,366
64,49
579,690
373,490
738,350
667,362
134,591
1064,808
438,212
53,215
226,533
359,416
989,603
1262,357
1096,64
701,544
890,570
358,296
821,175
851,33
356,826
1094,212
1213,428
596,390
1066,814
80,466
273,824
35,862
877,235
484,616
103,42
1181,810
385,435
768,736
1289,539
1173,568
760,847
826,726
808,631
714,388
274,135
900,752
808,263
810,57
468,887
38,824
907,826
1277,586
33,362
497,215
912,820
1054,397
512,658
64,497
410,814
689,301
756,533
1029,311
470,891
525,84
1002,474
540,248
664,501
912,72
70,8
353,162
1155,368
156,558
808,487
156,54
1300,260
192,67
33,273
338,266
909,92
117,814
1158,36
356,778
1258,516
1066,798
957,162
1228,768
361,469
157,215
810,505
687,413
335,37
1058,23
920,498
714,623
1282,137
1202,413
1076,122
251,327
310,469
1190,108
687,385
621,593
403,567
623,196
882,793
1228,590
408,477
296,72
114,248
808,256
469,828
825,456
718,9
1071,165
301,550
1169,882
1041,459
944,303
560,710
522,357
338,215
537,145
687,698
972,215
328,814
1265,404
321,74
909,597
1242,448
33,525
120,786
684,379
164,248
537,817
1158,401
329,259
349,210
1190,3
550,847
649,522
276,214
933,609
1248,73
542,158
842,332
842,108
726,366
1054,334
1168,645
252,871
681,792
602,29
1141,291
912,385
462,379
1174,495
633,38
20,310
1193,814
169,774
643,252
554,779
1002,722
1258,67
298,378
1054,547
502,858
1126,89
333,74
1014,520
1081,690
45,796
1081,466
146,469
909,166
902,752
1250,32
663,409
131,861
840,197
174,45
152,858
186,679
74,59
164,590
622,394
964,396
141,882
1153,663
584,8
909,728
321,7
1222,135
277,693
252,423
890,509
162,287
1071,266
110,627
305,38
1275,862
298,166
838,569
1054,484
493,595
110,491
381,455
572,687
70,120
773,817
229,204
566,135
18,50
114,390
565,26
902,466
1135,674
308,26
1210,485
502,493
944,555
256,560
1153,774
865,68
28,137
184,197
962,809
894,222
634,567
622,58
808,183
539,285
1277,397
522,537
112,158
1136,661
114,646
1200,280
1263,89
356,827
87,640
462,809
21,539
52,378
771,285
293,273
246,735
564,772
714,390
565,868
401,597
1034,438
621,621
1154,838
92,99
1300,186
1237,532
321,603
664,837
445,193
1092,831
234,401
100,745
1258,378
1198,127
550,411
1034,456
112,127
11,194
730,535
872,614
977,455
1174,719
937,190
950,836
237,280
661,344
246,204
1193,301
165,383
164,764
1009,102
994,268
373,190
1174,175
62,73
907,567
356,728
120,3
1252,56
209,641
113,226
821,595
738,277
1176,533
1009,498
687,196
1278,52
1179,861
502,519
1076,547
1169,12
882,37
244,814
661,550
925,659
1171,59
339,362
1076,285
1084,533
1210,745
808,519
764,749
689,273
1092,511
514,332
398,173
1014,72
401,138
1190,255
1250,862
622,388
687,478
333,372
370,190
694,385
1124,556
1056,749
649,792
154,729
301,844
329,635
58,838
940,190
281,641
515,387
813,215
841,262
617,556
1230,204
930,379
1012,291
1218,795
428,268
21,486
185,380
1029,583
315,586
281,583
100,268
1088,859
971,308
88,395
597,207
621,273
10,186
370,704
714,504
427,770
256,385
1218,544
485,829
59,318
744,135
160,607
972,716
440,736
291,862
20,584
840,891
294,500
920,457
776,639
679,435
276,227
1123,835
216,491
410,53
646,841
513,12
32,282
643,700
1158,455
1171,773
216,212
0,287
146,425
380,807
1138,57
932,227
555,539
21,42
346,396
688,282
385,431
398,273
428,857
132,313
540,646
52,827
161,859
1037,439
641,446
574,477
281,311
1198,158
1200,715
70,558
139,387
932,848
744,311
1002,172
964,26
169,120
301,498
642,364
580,731
909,354
217,7
1041,575
1289,38
1022,833
1279,481
1154,558
1196,504
104,607
415,809
1275,32
398,334
756,50
182,773
208,772
1154,728
1158,858
730,59
62,184
957,344
890,547
1176,591
73,362
515,507
1145,511
1277,621
62,9
1277,413
361,873
786,0
483,857
534,780
1252,838
796,332
1083,803
662,840
682,399
798,499
925,459
1228,687
895,316
541,276
208,324
523,705
907,292
468,332
1289,355
667,700
402,647
416,387
1054,560
31,481
920,396
234,45
fold along x=655
fold along y=447
fold along x=327
fold along y=223
fold along x=163
fold along y=111
fold along x=81
fold along y=55
fold along x=40
fold along y=27
fold along y=13
fold along y=6
| false |
42e5f7a0b1ef129f8884b119cfbc9171cc9c0684 | 1335ef22e0c7a074fb85cedd91d43518f0a960d7 | /Assignments/Assignment5/a5.rkt | 99985ffcd7b626f0d998ef1a2f9e8b8858e0b29d | []
| no_license | zhengguan/Scheme | 55d35fbf40790fd22cd98876dba484e5bd59ad99 | e27eedd2531c18a9b23134dc889a4ed1a0cd22c9 | refs/heads/master | 2021-01-13T04:58:50.945397 | 2014-12-19T05:24:36 | 2014-12-19T05:24:36 | 29,330,341 | 1 | 0 | null | 2015-01-16T03:12:28 | 2015-01-16T03:12:28 | null | UTF-8 | Racket | false | false | 6,549 | rkt | a5.rkt | #lang racket
(require C311/pmatch)
(require C311/trace)
;;(require "a5-student-tests.rkt")
;;(test-file #:file-name "a5.rkt")
;;---------------------------------------------------------------------------------------------------------------------------------------------------------
;;---------------------------------------------------------------------------------------------------------------------------------------------------------
;;Interpreters: four new versions of this interpreter, each one using a different parameter-passing convention.
;;call-by-value val-of-cbv
;;call-by-reference val-of-cbr
;;call-by-name val-of-cbname
;;call-by-need val-of-cbneed
;;AND
;;Brainteaser along with implementations of car, cons, cdr, car^, cons^, cdr^, add1, empty list, let and null? in function val-of-cbv
(define val-of-cbr
(lambda (exp env)
(pmatch exp
[`,n (guard (number? n)) n]
[`,x (guard (symbol? x)) (unbox (apply-env env x))]
[`,b (guard (boolean? b)) b]
[`(zero? ,n-exp) (zero? (val-of-cbr n-exp env))]
[`(* ,x ,y) (* (val-of-cbr x env) (val-of-cbr y env))]
[`(let ([ ,x ,val ]) ,body) (val-of-cbr body (extend-env x (val-of-cbr val env) env))]
[`(sub1 ,x) (sub1 (val-of-cbr x env))]
[`(if ,test-exp ,then-exp ,else-exp) (if (val-of-cbr test-exp env) (val-of-cbr then-exp env) (val-of-cbr else-exp env))]
[`(set! ,x ,rhs) (let ((vrhs (val-of-cbr rhs env))) (set-box! (apply-env env x) vrhs))]
[`(begin2 ,e1 ,e2) (begin (val-of-cbr e1 env) (val-of-cbr e2 env))]
[`(random ,n) (random (val-of-cbr n env))]
[`(lambda (,x) ,body) (closure-cbr x body env)]
[`(,rat ,x) (guard (symbol? x)) ((val-of-cbr rat env) (apply-env env x))]
[`(,rator ,rand) (apply-closure (val-of-cbr rator env) (box (val-of-cbr rand env)))])))
(define val-of-cbv
(lambda (exp env)
(pmatch exp
[`,n (guard (number? n)) n]
[`,x (guard (symbol? x)) (unbox (apply-env env x))]
[`,b (guard (boolean? b)) b]
[`(null? ,n-exp) (null? (val-of-cbv n-exp env))]
[`(add1 ,n-exp) (add1 (val-of-cbv n-exp env))]
[`(sub1 ,n-exp) (sub1 (val-of-cbv n-exp env))]
[`(quote ()) '()]
[`(car ,x) (car (val-of-cbv x env))]
[`(cdr ,x) (cdr (val-of-cbv x env))]
[`(cons ,x ,y) (cons (val-of-cbv x env) (val-of-cbv y env))]
[`(car^ ,x) ((car (val-of-cbv x env)))]
[`(cdr^ ,x) ((cdr (val-of-cbv x env)))]
[`(cons^ ,x ,y) (cons (lambda () (val-of-cbv x env)) (lambda () (val-of-cbv y env)))]
[`(zero? ,n-exp) (zero? (val-of-cbv n-exp env))]
[`(* ,x ,y) (* (val-of-cbv x env) (val-of-cbv y env))]
[`(let ([ ,x ,val ]) ,body) (val-of-cbv body (extend-env x (box (val-of-cbv val env)) env))]
[`(if ,test-exp ,then-exp ,else-exp) (if (val-of-cbv test-exp env) (val-of-cbv then-exp env) (val-of-cbv else-exp env))]
[`(set! ,x ,rhs) (let ((vrhs (val-of-cbv rhs env))) (set-box! (apply-env env x) vrhs))]
[`(begin2 ,e1 ,e2) (begin (val-of-cbv e1 env) (val-of-cbv e2 env))]
[`(random ,n) (random (val-of-cbv n env))]
[`(lambda (,x) ,body) (closure-cbv x body env)]
[`(,rat ,x) (guard (symbol? x)) ((val-of-cbv rat env) (box (unbox (apply-env env x))))]
[`(,rator ,rand) (apply-closure (val-of-cbv rator env) (box (val-of-cbv rand env)))])))
(define val-of-cbname
(lambda (exp env)
(pmatch exp
[`,n (guard (number? n)) n]
[`,x (guard (symbol? x)) ((unbox (apply-env env x)))]
[`,b (guard (boolean? b)) b]
[`(zero? ,n-exp) (zero? (val-of-cbname n-exp env))]
[`(* ,x ,y) (* (val-of-cbname x env) (val-of-cbname y env))]
[`(let ([ ,x ,val ]) ,body) (val-of-cbname body (extend-env x (val-of-cbname val env) env))]
[`(sub1 ,x) (sub1 (val-of-cbname x env))]
[`(if ,test-exp ,then-exp ,else-exp) (if (val-of-cbname test-exp env) (val-of-cbname then-exp env) (val-of-cbname else-exp env))]
[`(set! ,x ,rhs) (let ((vrhs (val-of-cbname rhs env))) (set-box! (apply-env env x) vrhs))]
[`(begin2 ,e1 ,e2) (begin (val-of-cbname e1 env) (val-of-cbname e2 env))]
[`(random ,n) (random (val-of-cbname n env))]
[`(lambda (,x) ,body) (closure-cbname x body env)]
[`(,rat ,x) (guard (symbol? x)) ((val-of-cbname rat env) (apply-env env x))]
[`(,rator ,rand) (apply-closure (val-of-cbname rator env) (box (lambda () (val-of-cbname rand env))))])))
(define val-of-cbneed
(lambda (exp env)
(pmatch exp
[`,n (guard (number? n)) n]
[`,x (guard (symbol? x)) (unbox/need (apply-env env x))]
[`,b (guard (boolean? b)) b]
[`(zero? ,n-exp) (zero? (val-of-cbneed n-exp env))]
[`(* ,x ,y) (* (val-of-cbneed x env) (val-of-cbneed y env))]
[`(let ([ ,x ,val ]) ,body) (val-of-cbneed body (extend-env x (val-of-cbneed val env) env))]
[`(sub1 ,x) (sub1 (val-of-cbneed x env))]
[`(if ,test-exp ,then-exp ,else-exp) (if (val-of-cbneed test-exp env) (val-of-cbneed then-exp env) (val-of-cbneed else-exp env))]
[`(set! ,x ,rhs) (let ((vrhs (val-of-cbneed rhs env))) (set-box! (apply-env env x) vrhs))]
[`(begin2 ,e1 ,e2) (begin (val-of-cbneed e1 env) (val-of-cbneed e2 env))]
[`(random ,n) (random (val-of-cbneed n env))]
[`(lambda (,x) ,body) (closure-cbneed x body env)]
[`(,rat ,x) (guard (symbol? x)) ((val-of-cbneed rat env) (apply-env env x))]
[`(,rator ,rand) (apply-closure (val-of-cbneed rator env) (box (lambda () (val-of-cbneed rand env))))])))
(define unbox/need
(lambda (x)
(let ([val ((unbox x))])
(set-box! x (lambda () val)) val)))
(define empty-env
(lambda ()
(lambda (y)
(error 'val-of "unbound variable ~s" y))))
(define extend-env
(lambda (x a env)
(lambda (y)
(if (eqv? x y) a (apply-env env y)))))
(define apply-env
(lambda (env y)
(env y)))
(define closure-cbr
(lambda (x body env)
(lambda (a)
(val-of-cbr body (extend-env x a env)))))
(define closure-cbv
(lambda (x body env)
(lambda (a)
(val-of-cbv body (extend-env x a env)))))
(define closure-cbname
(lambda (x body env)
(lambda (a)
(val-of-cbname body (extend-env x a env)))))
(define closure-cbneed
(lambda (x body env)
(lambda (a)
(val-of-cbneed body (extend-env x a env)))))
(define apply-closure
(lambda (p a)
(p a)))
;;------------------------------------------------------------------------------------------------------------------------------------------------------
;;------------------------------------------------------------------------------------------------------------------------------------------------------
(val-of-cbneed
((lambda (x) 120)
((lambda (x y) (y x y))
(lambda (y x) (y x y))
(lambda (x y) (x x y))))
(empty-env)) | false |
4c0e512cef23792d6fc64c4bac281f74dc381327 | a0c24087e281d33f73306f0399184cfc153ab9d5 | /Q021/Q021.rkt | 296c2d6bca5049a012e3b0e0964e5b8d8cb6df05 | []
| no_license | creasyw/project_euler | c94215886390cd2606c2c92af79008de4d67146f | b0584fb01ba2a255b2049a8cdc24fba98f46aff0 | refs/heads/master | 2021-11-19T10:39:48.946028 | 2021-10-12T03:59:34 | 2021-10-12T03:59:34 | 4,611,853 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 380 | rkt | Q021.rkt | #lang racket
(require "../factor.rkt")
(define amicable?
(lambda (n)
(letrec ((f1 (factors n))
(n2 (foldl + 0 (take f1 (- (length f1) 1))))
(f2 (factors n2)))
(and (not (= n n2))
(= n (foldl + 0 (take f2 (- (length f2) 1))))))))
(define (sum-amicable limit)
(foldl + 0 (filter amicable? (range 2 limit))))
(sum-amicable 10000) | false |
3de77f15863e0edf067b3a72302b419e5d285b1f | 0323f7dd61d190ea5b3693c2c4eaf3af95116ba8 | /naive-fxpa.rkt | 7ac5560b7a0441e6e8914c2cc5c46f31f70cf166 | [
"Apache-2.0",
"MIT"
]
| permissive | shaobo-he/naive-fxpa | 4b10e71ee47bae08ba2f00d0cfd16ef8bf519fef | a3efaca3fcc86103105628ea895ef829d6e808a4 | refs/heads/master | 2020-11-24T03:26:48.853823 | 2019-12-14T00:46:14 | 2019-12-14T00:46:14 | 227,945,650 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 5,116 | rkt | naive-fxpa.rkt | #lang typed/racket/base
(require
(for-syntax racket/base
racket/syntax
syntax/parse))
(provide
make-signature
get-total-bw
get-fb-bw
get-ib-bw
bits->ufp
bits->sfp
get-fp-value
fp+
fp-
fp*
fp/
fp<
fp<=
fp>
fp>=
fp=)
(define-type Signature (Pairof Positive-Integer Natural))
(: make-signature (-> Positive-Integer Natural Signature))
(define (make-signature tb fb)
(cons tb fb))
(: get-total-bw (-> Signature Positive-Integer))
(define (get-total-bw sig)
(car sig))
(: get-fb-bw (-> Signature Natural))
(define (get-fb-bw sig)
(cdr sig))
(: get-ib-bw (-> Signature Natural))
(define (get-ib-bw sig)
(define tb (get-total-bw sig))
(define fb (get-fb-bw sig))
(define ib (- tb fb))
(cond
[(>= ib 0) fb]
[else (error "invalid fp signature")]))
(struct FixedPoint
([sig : Signature])
#:transparent)
(struct UFixedPoint FixedPoint
([bits : Natural])
#:transparent)
(struct SFixedPoint FixedPoint
([bits : Integer])
#:transparent)
(: valid-range? (-> Signature Boolean Integer Boolean))
(define (valid-range? sig sign bits)
(define tb (get-total-bw sig))
(cond
[(not sign)
(and
(>= bits 0)
(< bits (expt 2 tb)))]
[else
(and
(>= bits (- (expt 2 (- tb 1))))
(< bits (expt 2 (- tb 1))))]))
(: bits->ufp (-> Natural Signature UFixedPoint))
(define (bits->ufp bits sig)
(cond
[(valid-range? sig #f bits) (UFixedPoint sig bits)]
[else (error "not valid bits!")]))
(: bits->sfp (-> Integer Signature SFixedPoint))
(define (bits->sfp bits sig)
(cond
[(valid-range? sig #t bits) (SFixedPoint sig bits)]
[else (error "not valid bits!")]))
(: get-fp-value (-> FixedPoint Exact-Rational))
(define (get-fp-value fp)
(define dem (expt 2 (get-fb-bw (FixedPoint-sig fp))))
(cond
[(UFixedPoint? fp) (/ (UFixedPoint-bits fp) dem)]
[(SFixedPoint? fp) (/ (SFixedPoint-bits fp) dem)]
[else (error "typed racket makes me do so!")]))
;; rounding mode
;; round up
(struct RU ())
;; round down
(struct RD ())
(define-type RM (U RU RD))
(: RoundUp RU)
(define RoundUp (RU))
(: RoundDown RD)
(define RoundDown (RD))
;; overflow mode
;; saturate
(struct ST ())
;; wrap around
(struct WP ())
(define-type OM (U ST WP))
(: Saturate ST)
(define Saturate (ST))
(: WrapAround WP)
(define WrapAround (WP))
(: saturate (-> Signature Boolean Integer Integer))
(define (saturate sig sign val)
(define tb (get-total-bw sig))
(define max-val
(- (expt 2 (if sign (- tb 1) tb)) 1))
(define min-val
(if sign (- (expt 2 (- tb 1))) 0))
(cond
[(> val max-val) max-val]
[(< val min-val) min-val]
[else val]))
(: wrap-around (-> Signature Boolean Integer Integer))
(define (wrap-around sig sign val)
(define tb (get-total-bw sig))
(cond
[sign (let ([offset (expt 2 (- tb 1))])
(- (modulo (+ val offset) (expt 2 tb)) offset))]
[else (modulo val (expt 2 tb))]))
(: handle-overflow (-> OM Signature Boolean Integer Integer))
(define (handle-overflow om sig sign val)
(cond
[(ST? om) (saturate sig sign val)]
[(WP? om) (wrap-around sig sign val)]))
(: handle-rounding (-> RM Signature Exact-Rational Integer))
(define (handle-rounding rm sig val)
(define fb (get-fb-bw sig))
(define bits-to-round (* val (expt 2 fb)))
(cond
[(RU? rm) (ceiling bits-to-round)]
[(RD? rm) (floor bits-to-round)]))
(: binop (-> OM RM (-> Exact-Rational Exact-Rational Exact-Rational) FixedPoint FixedPoint FixedPoint))
(define (binop om rm op f1 f2)
(define sig (FixedPoint-sig f1))
(define sign (SFixedPoint? f1))
(define v1 (get-fp-value f1))
(define v2 (get-fp-value f2))
(define res (op v1 v2))
(define res-after-round (handle-rounding rm sig res))
(define res-after-om (handle-overflow om sig sign res-after-round))
(cond
[(and (UFixedPoint? f1) (UFixedPoint? f2))
(if (>= res-after-om 0)
(UFixedPoint sig res-after-om)
(error "something is messed up!"))]
[(and (SFixedPoint? f2) (SFixedPoint? f2))
(SFixedPoint sig res-after-om)]
[else (error "type mismatch!")]))
(: fp+ (-> OM FixedPoint FixedPoint FixedPoint))
(define (fp+ om f1 f2)
(binop om (RU) + f1 f2))
(: fp- (-> OM FixedPoint FixedPoint FixedPoint))
(define (fp- om f1 f2)
(binop om (RU) - f1 f2))
(: fp* (-> OM RM FixedPoint FixedPoint FixedPoint))
(define (fp* om rm f1 f2)
(binop om rm * f1 f2))
(: fp/ (-> OM RM FixedPoint FixedPoint FixedPoint))
(define (fp/ om rm f1 f2)
(binop om rm / f1 f2))
(begin-for-syntax
(define (format-op-names op-names)
(map
(λ (op-name)
(format-id op-name "fp~a" op-name))
(syntax->list op-names))))
(define-syntax (define-bin-rel stx)
(syntax-case stx ()
[(_ op-name ...)
(with-syntax ([(op-name-q ...)
(format-op-names #'(op-name ...))])
#`(begin
(: op-name-q (-> FixedPoint FixedPoint Boolean)) ...
(define (op-name-q f1 f2)
(define v1 (get-fp-value f1))
(define v2 (get-fp-value f2))
(op-name v1 v2)) ...))]))
(define-bin-rel < <= > >= =) | true |
a8cb7234df9bbe4498c0a61ee3246c5d607d5ef6 | 3922167fbcc0655bb6fc8bb4886bf0e65d6a155a | /src/lib/dhash.rkt | 0485d91522b29ecc09adf03bb885f41f33db45d1 | [
"MIT"
]
| permissive | Gradual-Typing/Grift | d380b334aa53896d39c60c2e3008bfab73a55590 | 5fa76f837a0d6189332343d7aa899892b3c49583 | refs/heads/master | 2021-11-23T07:25:24.221457 | 2021-11-04T14:35:53 | 2021-11-04T14:35:53 | 27,832,586 | 70 | 12 | MIT | 2021-09-30T14:03:22 | 2014-12-10T18:06:44 | C | UTF-8 | Racket | false | false | 2,084 | rkt | dhash.rkt | #lang typed/racket/base/no-check
(require racket/match)
(provide (all-defined-out))
(struct (K V) DHash ([content : (Mutable-HashTable K V)] [seq : (Listof K)])
#:mutable
#:transparent)
(: make-dhasheq (All (K V) (->* () ((Listof (Pair K V))) (DHash K V))))
(define (make-dhasheq [als : (Listof (Pair K V)) '()])
(define ht : (Mutable-HashTable K V) (make-hasheq))
(define dht : (DHash K V) (DHash ht '()))
(for ([p als])
(match p
[(cons k v) (dhash-set! dht k v)]
[_ (raise-argument-error 'make-dhasheq "alist?" als)]))
dht)
(: dhash-set! (All (K V) (DHash K V) K V -> Void))
(define (dhash-set! dht k v)
(match-define (DHash c s) dht)
(define before-count (hash-count c))
(hash-set! c k v)
(unless (= before-count (hash-count c))
(set-DHash-seq! dht (cons k s))))
(: missing-key (All (K V) K -> (-> V)))
(define ((missing-key k))
(error 'dhash-ref "key, ~a, not found" k))
(: dhash-ref
(All (K V)
(case->
[(DHash K V) K -> V]
[(DHash K V) K False -> (Option V)]
[(DHash K V) K (-> V) -> V])))
(define (dhash-ref dht k [default 'dhash-ref/no-default-passed])
(cond
[(eq? default 'dhash-ref/no-default-passed)
(hash-ref (DHash-content dht) k (missing-key k))]
[else (hash-ref (DHash-content dht) k default)]))
(: dhash-ref! (All (K V) (DHash K V) K (-> V) -> V))
(define (dhash-ref! dht k v)
(match-define (DHash c s) dht)
(define (th-v) : V
(set-DHash-seq! dht (cons k s))
(v))
(hash-ref! c k th-v))
(: dhash-has-key? (All (K V) (DHash K V) K -> Boolean))
(define (dhash-has-key? dht k)
(hash-has-key? (DHash-content dht) k))
(: dhash-remove! (All (K V) (DHash K V) K -> Void))
(define (dhash-remove! dht k)
(hash-remove! (DHash-content dht) k))
(: dhash-keys (All (K V) (DHash K V) -> (Listof K)))
(define (dhash-keys dht)
(match-define (DHash c s) dht)
(: has? : K -> Boolean)
(define (has? k) (hash-has-key? c k))
(filter has? s))
(: in-dhash-keys (All (K V) (DHash K V) -> (Sequenceof K)))
(define (in-dhash-keys dht) (in-list (dhash-keys dht)))
| false |
94498fe1fad262f3d585e7f52d03addc8b917878 | 65c1f9548ad23d102a42be54ae7ef16f54767dba | /gregor-lib/gregor/private/parse.rkt | 1e3c56beea3ef3c2f7d2a1bbc18a72d0ffa3550e | [
"MIT"
]
| permissive | 97jaz/gregor | ea52754ce7aa057941a5a7080415768687cc4764 | 2d20192e8795e01a1671869dddaf1984f0cbafee | refs/heads/master | 2022-07-20T12:52:15.088073 | 2022-06-28T09:48:59 | 2022-07-19T16:01:18 | 32,499,398 | 45 | 11 | null | 2022-06-28T09:50:43 | 2015-03-19T03:47:23 | Racket | UTF-8 | Racket | false | false | 3,704 | rkt | parse.rkt | #lang racket/base
(require racket/contract/base
racket/match
cldr/core
cldr/likely-subtags
"date.rkt"
"datetime.rkt"
"exn.rkt"
"moment.rkt"
"offset-resolvers.rkt"
"time.rkt"
"pattern/ast.rkt"
"pattern/lexer.rkt"
"pattern/parse-state.rkt")
(define (parse-temporal input
pattern
ci?
locale
make-temporal)
(define cldr-locale (locale->available-cldr-locale locale modern-locale?))
(define initial-state (parse-state input (fresh-fields)))
(define ast-nodes (pattern->ast-list pattern))
(define next-ast-nodes
(if (null? ast-nodes)
null
(append (cdr ast-nodes) (list #f))))
(match-define (parse-state remaining-input fields)
(for/fold ([s initial-state]) ([node (in-list ast-nodes)]
[next-node (in-list next-ast-nodes)])
(ast-parse node next-node s ci? cldr-locale)))
(cond [(zero? (string-length remaining-input))
(make-temporal fields)]
[else
(err "Unable to match pattern [~a] against input [~a]"
pattern input)]))
(define (parse-moment input
pattern
#:ci? [ci? #t]
#:locale [locale (current-locale)]
#:resolve-offset [resolve resolve-offset/raise])
(parse-temporal input pattern ci? locale
(λ (fields)
(match (fields->datetime+tz fields err)
[(cons dt tz) (datetime+tz->moment dt tz resolve)]))))
(define (parse-datetime input
pattern
#:ci? [ci? #t]
#:locale [locale (current-locale)])
(parse-temporal input pattern ci? locale
(λ (fields)
(match (fields->datetime+tz fields err)
[(cons dt _) dt]))))
(define (parse-date input
pattern
#:ci? [ci? #t]
#:locale [locale (current-locale)])
(parse-temporal input pattern ci? locale
(λ (fields)
(match (fields->datetime+tz fields err)
[(cons dt _) (datetime->date dt)]))))
(define (parse-time input
pattern
#:ci? [ci? #t]
#:locale [locale (current-locale)])
(parse-temporal input pattern ci? locale
(λ (fields)
(fields->time fields err))))
(define (err fmt . args)
(raise (exn:gregor:parse (apply format fmt args)
(current-continuation-marks))))
(provide/contract
[parse-moment (->i ([input string?]
[pattern string?])
(#:ci? [ci? boolean?]
#:locale [locale string?]
#:resolve-offset [resolve offset-resolver/c])
[m moment?])]
[parse-datetime (->i ([input string?]
[pattern string?])
(#:ci? [ci? boolean?]
#:locale [locale string?])
[dt datetime?])]
[parse-date (->i ([input string?]
[pattern string?])
(#:ci? [ci? boolean?]
#:locale [locale string?])
[d date?])]
[parse-time (->i ([input string?]
[pattern string?])
(#:ci? [ci? boolean?]
#:locale [locale string?])
[t time?])])
| false |
d7da5276e8ac5aa9a470d735300c8e3858d7b4f7 | 400da1df8111d5d506bc02dd2041d980429f7840 | /plisqin-doc/scribblings/for-developers.scrbl | 626ed2c07536743d90c2c5816a4f6b8cde46ef48 | [
"MIT"
]
| permissive | default-kramer/plisqin | b60856520d03441f88d0e5bf74d5e6dc950cd12e | 26421c7c42656c873c4e0a4fc7f48c0a3ed7770f | refs/heads/master | 2021-07-07T20:45:59.813501 | 2020-08-09T18:43:39 | 2020-08-09T18:43:39 | 158,136,834 | 9 | 0 | MIT | 2020-08-09T18:43:40 | 2018-11-18T23:24:20 | Racket | UTF-8 | Racket | false | false | 2,157 | scrbl | for-developers.scrbl | #lang scribble/manual
@title{For Developers}
This documentation is not written for a user of Plisqin, but you
might find something useful anyway.
@section{Needed for 0.2}
@itemlist[
@item{Remove number? from sql-token? - need param or val.}
@item{raw-sql NEEDS to look different than a regular string in error messages}
@item{and, or, not}
@item{the literal rewrites (or syntax parameters) of 'asc 'desc 'null}
@item{something for sql-null}
@item{Lots of testing needed - do rebuild views / SPs}
@item{Lots of missing documentation}
@item{Document the 3 modes (offline SQL gen, compile-time gen, runtime-gen (eager or lazy)).}
]
@section{Nice to have for 0.2}
@itemlist[
@item{Compile-time SQL generation for Racket programs}
@item{as-name inference}
@item{via! and maybe def/append! could maybe detect infinite recursion and other errors?}
@item{Support for update and delete}
@item{Overhaul query printing / that to-list stuff}
@item{rename binding? to attached-join?}
@item{Split core lib from extras, like the examples}
]
@section{What Else}
@itemlist[
@item{What type system should Plisqin have? Dynamic, sure, but what about...}
@item{Can @(racket (scalar x".Foo")) be used in addition? (A: Maybe?)}
@item{Can @(racket (scalar x".Foo" #:typed-as 'decimal)) be used in addition? (A: Always.)}
@item{Can @(racket (scalar x".Foo" #:typed-as 'varchar)) be used in addition? (A: Never.)}
@item{If I integrate with Postgres/SQLite, could it detect the type errors
after I translate the query to its native format?}
@item{Would I want it to? Probably not... I can't imagine the semantics being similar enough.}
@item{How should Plisqin handle NULL?}
@item{Some aggregate operations have reasonable answers for empty grouped joins
(specifically @(racket sum) and @(racket count) which should return 0.)
But what about other aggregates? What is the average of an empty set?
Force the programmer to specify what they want?}
@item{Can I satisfy people who have never seen (or hate) Lisp without sacrificing power?}
@item{Can Plisqin provide a uniform API for different databases?}]
@(include-section "design-notes.scrbl")
| false |
26200bbde9b64504144fa761c812fa8890671b1a | 627680558b42ab91471b477467187c3f24b99082 | /results/24-hr/stlc-sub-3-enum.rktd | f533fc4c5ae00945528425abef4e1fcdf4f7ae6d | []
| no_license | bfetscher/dissertation | 2a579aa919d6173a211560e20630b3920d108412 | 148d7f9bb21ce29b705522f7f4967d63bffc67cd | refs/heads/master | 2021-01-12T12:57:45.507113 | 2016-10-06T06:54:21 | 2016-10-06T06:54:21 | 70,130,350 | 0 | 1 | null | 2016-10-06T14:01:38 | 2016-10-06T06:58:19 | Racket | UTF-8 | Racket | false | false | 664,413 | rktd | stlc-sub-3-enum.rktd | (start 2015-08-18T16:09:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:09:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:09:50 (#:amount 12862904 #:time 261))
(heartbeat 2015-08-18T16:10:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:10:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:10:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:10:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:10:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:10:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:11:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:11:04 (#:amount 89502584 #:time 291))
(heartbeat 2015-08-18T16:11:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:11:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:11:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:11:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:11:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:12:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:12:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:12:11 (#:amount 97061432 #:time 298))
(heartbeat 2015-08-18T16:12:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:12:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:12:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:12:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:13:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:13:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:13:13 (#:amount 92203232 #:time 299))
(heartbeat 2015-08-18T16:13:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:13:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:13:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:13:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:14:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:14:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:14:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:14:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:14:30 (#:amount 95994376 #:time 351))
(heartbeat 2015-08-18T16:14:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:14:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:15:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:15:52 (#:amount 92293328 #:time 345))
(heartbeat 2015-08-18T16:16:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:16:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:16:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:16:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:16:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:16:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:17:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:17:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:17:12 (#:amount 95271032 #:time 296))
(heartbeat 2015-08-18T16:17:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:17:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:17:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:17:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:18:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:18:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:18:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:18:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:18:37 (#:amount 92970024 #:time 358))
(heartbeat 2015-08-18T16:18:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:18:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:19:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:20:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:20:05 (#:amount 96061384 #:time 359))
(heartbeat 2015-08-18T16:20:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:20:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:20:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:20:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:20:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:21:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:21:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:21:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:21:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:21:33 (#:amount 92749328 #:time 351))
(heartbeat 2015-08-18T16:21:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:21:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:22:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:22:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:22:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:22:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:22:40 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T16:22:50 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 71) #:iterations 59340 #:time 780489))
(new-average 2015-08-18T16:22:50 (#:model "stlc-sub-3" #:type enum #:average 780488.0 #:stderr +nan.0))
(heartbeat 2015-08-18T16:22:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:23:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:23:03 (#:amount 96538768 #:time 349))
(heartbeat 2015-08-18T16:23:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:23:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:23:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:23:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:23:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:24:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:24:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:24:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:24:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:24:30 (#:amount 93260608 #:time 345))
(heartbeat 2015-08-18T16:24:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:24:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:25:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:25:59 (#:amount 95862320 #:time 353))
(heartbeat 2015-08-18T16:26:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:26:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:26:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:26:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:26:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:26:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:27:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:27:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:27:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:27:28 (#:amount 92967392 #:time 347))
(heartbeat 2015-08-18T16:27:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:27:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:27:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:28:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:28:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:28:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:28:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:28:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:28:47 (#:amount 96484272 #:time 350))
(heartbeat 2015-08-18T16:28:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:29:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:30:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:30:06 (#:amount 93119832 #:time 296))
(heartbeat 2015-08-18T16:30:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:30:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:30:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:30:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:30:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:31:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:31:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:31:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:31:25 (#:amount 96000160 #:time 349))
(heartbeat 2015-08-18T16:31:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:31:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:31:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:32:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:32:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:32:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:32:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:32:38 (#:amount 92915128 #:time 294))
(heartbeat 2015-08-18T16:32:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:32:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:33:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:33:53 (#:amount 96579632 #:time 348))
(heartbeat 2015-08-18T16:34:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:34:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:34:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:34:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:34:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:34:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:35:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:35:10 (#:amount 92880232 #:time 311))
(heartbeat 2015-08-18T16:35:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:35:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:35:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:35:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:35:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:36:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:36:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:36:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:36:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:36:32 (#:amount 96436712 #:time 358))
(heartbeat 2015-08-18T16:36:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:36:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:37:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:37:53 (#:amount 92862064 #:time 349))
(heartbeat 2015-08-18T16:38:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:38:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:38:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:38:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:38:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:38:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:39:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:39:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:39:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:39:24 (#:amount 96615584 #:time 329))
(heartbeat 2015-08-18T16:39:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:39:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:39:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:40:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:40:54 (#:amount 92891640 #:time 350))
(heartbeat 2015-08-18T16:41:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:41:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:41:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:41:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:41:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:41:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:42:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:42:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:42:13 (#:amount 96545968 #:time 351))
(heartbeat 2015-08-18T16:42:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:42:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:42:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:42:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:43:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:43:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:43:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:43:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:43:38 (#:amount 93122560 #:time 347))
(heartbeat 2015-08-18T16:43:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:43:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:44:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:45:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:45:06 (#:amount 96233896 #:time 348))
(heartbeat 2015-08-18T16:45:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:45:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:45:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:45:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:45:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:46:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:46:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:46:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:46:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:46:35 (#:amount 93015128 #:time 349))
(heartbeat 2015-08-18T16:46:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:46:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:47:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:48:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:48:05 (#:amount 96502600 #:time 348))
(heartbeat 2015-08-18T16:48:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:48:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:48:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:48:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:48:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:49:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:49:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:49:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:49:28 (#:amount 92737968 #:time 348))
(heartbeat 2015-08-18T16:49:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:49:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:49:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:50:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:50:58 (#:amount 96966448 #:time 350))
(heartbeat 2015-08-18T16:51:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:51:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:51:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:51:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:51:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:51:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:52:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:52:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:52:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:52:24 (#:amount 93023584 #:time 347))
(heartbeat 2015-08-18T16:52:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:52:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:52:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:53:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:53:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:53:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:53:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:53:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:53:46 (#:amount 96315568 #:time 346))
(heartbeat 2015-08-18T16:53:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:54:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:55:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:55:08 (#:amount 93060304 #:time 348))
(heartbeat 2015-08-18T16:55:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:55:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:55:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:55:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:55:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:56:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:56:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:56:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:56:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:56:33 (#:amount 96316728 #:time 296))
(heartbeat 2015-08-18T16:56:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:56:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:57:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:57:54 (#:amount 93056304 #:time 311))
(heartbeat 2015-08-18T16:58:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:58:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:58:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:58:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:58:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:58:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:59:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:59:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T16:59:19 (#:amount 96275376 #:time 353))
(heartbeat 2015-08-18T16:59:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:59:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:59:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T16:59:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:00:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:00:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:00:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:00:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:00:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:00:45 (#:amount 92814424 #:time 344))
(heartbeat 2015-08-18T17:00:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:01:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:02:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:02:11 (#:amount 96521264 #:time 350))
(heartbeat 2015-08-18T17:02:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:02:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:02:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:02:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:02:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:03:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:03:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:03:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:03:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:03:35 (#:amount 93137608 #:time 290))
(heartbeat 2015-08-18T17:03:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:03:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:04:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:04:58 (#:amount 96180168 #:time 350))
(heartbeat 2015-08-18T17:05:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:05:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:05:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:05:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:05:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:05:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:06:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:06:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:06:18 (#:amount 93090552 #:time 292))
(heartbeat 2015-08-18T17:06:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:06:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:06:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:06:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:07:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:07:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:07:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:07:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:07:33 (#:amount 96351768 #:time 350))
(heartbeat 2015-08-18T17:07:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:07:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:08:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:09:00 (#:amount 93017152 #:time 348))
(heartbeat 2015-08-18T17:09:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:09:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:09:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:09:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:09:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:09:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:10:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:10:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:10:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:10:30 (#:amount 96243584 #:time 353))
(heartbeat 2015-08-18T17:10:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:10:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:10:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:11:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:11:55 (#:amount 93018496 #:time 344))
(heartbeat 2015-08-18T17:12:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:12:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:12:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:12:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:12:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:12:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:13:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:13:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:13:17 (#:amount 96568160 #:time 349))
(heartbeat 2015-08-18T17:13:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:13:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:13:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:13:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:14:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:14:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:14:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:14:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:14:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:14:42 (#:amount 93101440 #:time 349))
(heartbeat 2015-08-18T17:14:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:15:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:16:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:16:09 (#:amount 96268432 #:time 351))
(heartbeat 2015-08-18T17:16:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:16:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:16:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:16:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:16:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:17:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:17:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:17:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:17:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:17:35 (#:amount 92921312 #:time 347))
(heartbeat 2015-08-18T17:17:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:17:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:18:52 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T17:19:02 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -21) #:iterations 243933 #:time 3372653))
(new-average 2015-08-18T17:19:02 (#:model "stlc-sub-3" #:type enum #:average 2076570.5 #:stderr 1296082.5))
(heartbeat 2015-08-18T17:19:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:19:06 (#:amount 96585560 #:time 352))
(heartbeat 2015-08-18T17:19:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:19:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:19:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:19:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:19:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:20:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:20:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:20:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:20:32 (#:amount 93096440 #:time 343))
(heartbeat 2015-08-18T17:20:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:20:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:20:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:21:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:21:59 (#:amount 96087856 #:time 357))
(heartbeat 2015-08-18T17:22:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:22:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:22:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:22:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:22:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:22:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:23:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:23:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:23:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:23:25 (#:amount 93159592 #:time 347))
(heartbeat 2015-08-18T17:23:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:23:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:23:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:24:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:24:57 (#:amount 96300000 #:time 352))
(heartbeat 2015-08-18T17:25:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:25:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:25:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:25:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:25:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:25:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:26:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:26:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:26:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:26:26 (#:amount 93023616 #:time 347))
(heartbeat 2015-08-18T17:26:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:26:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:26:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:27:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:27:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:27:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:27:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:27:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:27:46 (#:amount 96453832 #:time 332))
(heartbeat 2015-08-18T17:27:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:28:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:29:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:29:02 (#:amount 92725392 #:time 296))
(heartbeat 2015-08-18T17:29:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:29:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:29:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:29:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:29:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:30:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:30:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:30:19 (#:amount 96735136 #:time 299))
(heartbeat 2015-08-18T17:30:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:30:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:30:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:30:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:31:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:31:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:31:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:31:27 (#:amount 93135560 #:time 297))
(heartbeat 2015-08-18T17:31:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:31:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:31:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:32:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:32:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:32:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:32:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:32:41 (#:amount 96283832 #:time 296))
(heartbeat 2015-08-18T17:32:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:32:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:33:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:33:59 (#:amount 92971664 #:time 297))
(heartbeat 2015-08-18T17:34:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:34:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:34:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:34:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:34:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:34:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:35:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:35:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:35:16 (#:amount 96437688 #:time 351))
(heartbeat 2015-08-18T17:35:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:35:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:35:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:35:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:36:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:36:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:36:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:36:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:36:37 (#:amount 93218208 #:time 345))
(heartbeat 2015-08-18T17:36:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:36:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:37:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:37:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:37:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:37:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:37:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:37:46 (#:amount 95963120 #:time 316))
(heartbeat 2015-08-18T17:37:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:38:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:39:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:39:07 (#:amount 92969704 #:time 291))
(heartbeat 2015-08-18T17:39:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:39:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:39:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:39:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:39:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:40:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:40:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:40:15 (#:amount 96351248 #:time 295))
(heartbeat 2015-08-18T17:40:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:40:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:40:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:40:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:41:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:41:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:41:18 (#:amount 93012368 #:time 292))
(heartbeat 2015-08-18T17:41:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:41:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:41:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:41:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:42:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:42:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:42:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:42:24 (#:amount 96410128 #:time 307))
(heartbeat 2015-08-18T17:42:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:42:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:42:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:43:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:43:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:43:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:43:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:43:34 (#:amount 93096272 #:time 347))
(heartbeat 2015-08-18T17:43:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:43:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:44:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:44:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:44:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:44:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:44:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:44:52 (#:amount 96472056 #:time 297))
(heartbeat 2015-08-18T17:44:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:45:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:45:58 (#:amount 92816312 #:time 348))
(heartbeat 2015-08-18T17:46:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:46:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:46:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:46:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:46:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:46:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:47:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:47:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:47:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:47:29 (#:amount 96667528 #:time 352))
(heartbeat 2015-08-18T17:47:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:47:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:47:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:48:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:49:01 (#:amount 92968144 #:time 347))
(heartbeat 2015-08-18T17:49:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:49:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:49:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:49:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:49:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:49:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:50:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:50:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:50:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:50:32 (#:amount 96751552 #:time 355))
(heartbeat 2015-08-18T17:50:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:50:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:50:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:51:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:52:01 (#:amount 93161536 #:time 346))
(heartbeat 2015-08-18T17:52:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:52:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:52:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:52:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:52:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:52:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:53:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:53:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:53:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:53:30 (#:amount 96521264 #:time 347))
(heartbeat 2015-08-18T17:53:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:53:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:53:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:54:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:54:57 (#:amount 93090384 #:time 345))
(heartbeat 2015-08-18T17:55:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:55:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:55:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:55:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:55:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:55:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:56:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:56:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:56:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:56:26 (#:amount 96254824 #:time 352))
(heartbeat 2015-08-18T17:56:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:56:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:56:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:57:53 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T17:57:54 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (b int) ((λ (a int) a) b)) 1891) #:iterations 176546 #:time 2332395))
(new-average 2015-08-18T17:57:54 (#:model "stlc-sub-3" #:type enum #:average 2161845.3333333335 #:stderr 753136.8265254182))
(gc-major 2015-08-18T17:57:55 (#:amount 93109304 #:time 349))
(heartbeat 2015-08-18T17:58:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:58:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:58:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:58:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:58:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:58:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:59:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:59:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:59:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T17:59:25 (#:amount 96355080 #:time 359))
(heartbeat 2015-08-18T17:59:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:59:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T17:59:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:00:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:00:55 (#:amount 93130888 #:time 312))
(heartbeat 2015-08-18T18:01:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:01:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:01:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:01:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:01:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:01:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:02:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:02:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:02:23 (#:amount 96169360 #:time 350))
(heartbeat 2015-08-18T18:02:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:02:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:02:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:02:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:03:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:03:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:03:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:03:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:03:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:03:52 (#:amount 93101944 #:time 347))
(heartbeat 2015-08-18T18:03:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:04:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:05:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:05:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:05:23 (#:amount 96411904 #:time 356))
(heartbeat 2015-08-18T18:05:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:05:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:05:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:05:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:06:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:06:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:06:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:06:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:06:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:06:50 (#:amount 92935592 #:time 290))
(heartbeat 2015-08-18T18:06:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:07:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:08:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:08:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:08:15 (#:amount 96464984 #:time 298))
(heartbeat 2015-08-18T18:08:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:08:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:08:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:08:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:09:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:09:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:09:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:09:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:09:34 (#:amount 92948840 #:time 294))
(heartbeat 2015-08-18T18:09:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:09:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:10:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:10:57 (#:amount 96376768 #:time 351))
(heartbeat 2015-08-18T18:11:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:11:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:11:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:11:34 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T18:11:39 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 7) #:iterations 57809 #:time 825562))
(new-average 2015-08-18T18:11:39 (#:model "stlc-sub-3" #:type enum #:average 1827774.5 #:stderr 628657.9844545177))
(heartbeat 2015-08-18T18:11:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:11:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:12:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:12:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:12:23 (#:amount 93134112 #:time 344))
(heartbeat 2015-08-18T18:12:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:12:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:12:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:12:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:13:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:13:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:13:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:13:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:13:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:13:49 (#:amount 96240296 #:time 353))
(heartbeat 2015-08-18T18:13:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:14:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:15:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:15:08 (#:amount 93077288 #:time 348))
(heartbeat 2015-08-18T18:15:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:15:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:15:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:15:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:15:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:16:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:16:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:16:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:16:29 (#:amount 96509976 #:time 346))
(heartbeat 2015-08-18T18:16:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:16:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:16:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:17:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:17:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:17:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:17:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:17:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:17:47 (#:amount 93005944 #:time 344))
(heartbeat 2015-08-18T18:17:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:18:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:19:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:19:07 (#:amount 96366416 #:time 346))
(heartbeat 2015-08-18T18:19:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:19:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:19:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:19:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:19:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:20:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:20:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:20:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:20:30 (#:amount 92716952 #:time 348))
(heartbeat 2015-08-18T18:20:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:20:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:20:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:21:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:21:56 (#:amount 96812712 #:time 348))
(heartbeat 2015-08-18T18:22:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:22:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:22:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:22:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:22:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:22:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:23:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:23:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:23:16 (#:amount 93170248 #:time 344))
(heartbeat 2015-08-18T18:23:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:23:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:23:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:23:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:24:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:24:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:24:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:24:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:24:41 (#:amount 96061032 #:time 352))
(heartbeat 2015-08-18T18:24:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:24:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:25:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:26:00 (#:amount 93011184 #:time 294))
(heartbeat 2015-08-18T18:26:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:26:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:26:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:26:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:26:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:26:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:27:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:27:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:27:24 (#:amount 96394416 #:time 353))
(heartbeat 2015-08-18T18:27:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:27:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:27:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:27:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:28:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:28:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:28:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:28:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:28:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:28:48 (#:amount 93215496 #:time 347))
(heartbeat 2015-08-18T18:28:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:29:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:30:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:30:13 (#:amount 96164504 #:time 350))
(heartbeat 2015-08-18T18:30:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:30:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:30:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:30:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:30:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:31:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:31:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:31:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:31:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:31:40 (#:amount 93282512 #:time 347))
(heartbeat 2015-08-18T18:31:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:31:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:32:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:33:03 (#:amount 95885280 #:time 355))
(heartbeat 2015-08-18T18:33:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:33:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:33:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:33:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:33:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:33:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:34:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:34:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:34:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:34:28 (#:amount 93336624 #:time 294))
(heartbeat 2015-08-18T18:34:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:34:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:34:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:35:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:35:57 (#:amount 95950128 #:time 347))
(heartbeat 2015-08-18T18:36:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:36:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:36:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:36:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:36:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:36:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:37:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:37:15 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T18:37:24 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -21) #:iterations 112155 #:time 1546078))
(new-average 2015-08-18T18:37:24 (#:model "stlc-sub-3" #:type enum #:average 1771435.2 #:stderr 490204.6853871757))
(heartbeat 2015-08-18T18:37:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:37:27 (#:amount 92810008 #:time 344))
(heartbeat 2015-08-18T18:37:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:37:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:37:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:38:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:38:58 (#:amount 96716000 #:time 356))
(heartbeat 2015-08-18T18:39:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:39:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:39:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:39:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:39:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:39:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:40:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:40:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:40:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:40:29 (#:amount 93296496 #:time 345))
(heartbeat 2015-08-18T18:40:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:40:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:40:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:41:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:42:00 (#:amount 96006032 #:time 351))
(heartbeat 2015-08-18T18:42:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:42:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:42:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:42:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:42:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:42:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:43:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:43:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:43:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:43:30 (#:amount 93239656 #:time 346))
(heartbeat 2015-08-18T18:43:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:43:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:43:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:44:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:45:02 (#:amount 96042760 #:time 350))
(heartbeat 2015-08-18T18:45:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:45:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:45:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:45:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:45:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:45:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:46:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:46:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:46:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:46:32 (#:amount 93075472 #:time 344))
(heartbeat 2015-08-18T18:46:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:46:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:46:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:47:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:48:02 (#:amount 96317560 #:time 351))
(heartbeat 2015-08-18T18:48:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:48:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:48:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:48:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:48:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:48:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:49:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:49:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:49:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:49:29 (#:amount 92928952 #:time 348))
(heartbeat 2015-08-18T18:49:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:49:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:49:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:50:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:50:59 (#:amount 96838304 #:time 351))
(heartbeat 2015-08-18T18:51:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:51:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:51:25 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T18:51:30 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ɸ ((((list int) → int) → ((list int) → int)) → ((int → (list int)) → (list int)))) ((λ (a int) (cons a)) 52)) #:iterations 56991 #:time 845926))
(new-average 2015-08-18T18:51:30 (#:model "stlc-sub-3" #:type enum #:average 1617183.6666666665 #:stderr 428945.16889618634))
(heartbeat 2015-08-18T18:51:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:51:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:51:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:52:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:52:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:52:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:52:27 (#:amount 92959840 #:time 348))
(heartbeat 2015-08-18T18:52:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:52:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:52:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:53:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:53:59 (#:amount 96410432 #:time 358))
(heartbeat 2015-08-18T18:54:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:54:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:54:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:54:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:54:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:54:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:55:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:55:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:55:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:55:30 (#:amount 93329984 #:time 354))
(heartbeat 2015-08-18T18:55:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:55:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:55:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:56:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:57:01 (#:amount 95993472 #:time 354))
(heartbeat 2015-08-18T18:57:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:57:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:57:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:57:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:57:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:57:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:58:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:58:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:58:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T18:58:30 (#:amount 92937704 #:time 350))
(heartbeat 2015-08-18T18:58:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:58:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:58:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T18:59:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:00:02 (#:amount 96641792 #:time 357))
(heartbeat 2015-08-18T19:00:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:00:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:00:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:00:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:00:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:00:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:01:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:01:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:01:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:01:32 (#:amount 93017632 #:time 348))
(heartbeat 2015-08-18T19:01:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:01:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:01:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:02:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:03:04 (#:amount 96536456 #:time 353))
(heartbeat 2015-08-18T19:03:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:03:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:03:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:03:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:03:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:03:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:04:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:04:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:04:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:04:33 (#:amount 93105464 #:time 351))
(heartbeat 2015-08-18T19:04:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:04:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:04:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:05:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:06:01 (#:amount 96309408 #:time 349))
(heartbeat 2015-08-18T19:06:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:06:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:06:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:06:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:06:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:06:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:07:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:07:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:07:21 (#:amount 92999032 #:time 342))
(heartbeat 2015-08-18T19:07:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:07:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:07:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:07:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:08:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:08:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:08:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:08:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:08:44 (#:amount 96235416 #:time 350))
(heartbeat 2015-08-18T19:08:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:08:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:09:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:10:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:10:10 (#:amount 93088472 #:time 343))
(heartbeat 2015-08-18T19:10:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:10:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:10:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:10:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:10:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:11:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:11:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:11:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:11:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:11:40 (#:amount 96368272 #:time 352))
(heartbeat 2015-08-18T19:11:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:11:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:12:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:13:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:13:07 (#:amount 93188272 #:time 343))
(heartbeat 2015-08-18T19:13:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:13:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:13:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:13:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:13:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:14:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:14:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:14:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:14:28 (#:amount 96376960 #:time 351))
(heartbeat 2015-08-18T19:14:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:14:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:14:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:15:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:15:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:15:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:15:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:15:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:15:51 (#:amount 93251312 #:time 345))
(heartbeat 2015-08-18T19:15:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:16:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:17:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:17:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:17:20 (#:amount 95984272 #:time 354))
(heartbeat 2015-08-18T19:17:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:17:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:17:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:17:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:18:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:18:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:18:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:18:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:18:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:18:48 (#:amount 92859048 #:time 348))
(heartbeat 2015-08-18T19:18:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:19:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:20:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:20:16 (#:amount 96803976 #:time 351))
(heartbeat 2015-08-18T19:20:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:20:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:20:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:20:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:20:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:21:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:21:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:21:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:21:35 (#:amount 92671936 #:time 344))
(heartbeat 2015-08-18T19:21:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:21:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:21:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:22:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:23:02 (#:amount 97140128 #:time 351))
(heartbeat 2015-08-18T19:23:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:23:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:23:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:23:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:23:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:23:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:24:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:24:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:24:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:24:30 (#:amount 92826696 #:time 347))
(heartbeat 2015-08-18T19:24:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:24:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:24:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:25:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:26:00 (#:amount 96742472 #:time 350))
(heartbeat 2015-08-18T19:26:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:26:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:26:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:26:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:26:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:26:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:27:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:27:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:27:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:27:29 (#:amount 93048840 #:time 349))
(heartbeat 2015-08-18T19:27:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:27:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:27:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:28:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:29:01 (#:amount 96252664 #:time 352))
(heartbeat 2015-08-18T19:29:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:29:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:29:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:29:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:29:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:29:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:30:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:30:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:30:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:30:31 (#:amount 92958712 #:time 351))
(heartbeat 2015-08-18T19:30:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:30:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:30:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:31:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:32:03 (#:amount 96594680 #:time 361))
(heartbeat 2015-08-18T19:32:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:32:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:32:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:32:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:32:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:32:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:33:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:33:15 (#:amount 93019104 #:time 299))
(heartbeat 2015-08-18T19:33:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:33:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:33:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:33:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:33:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:34:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:34:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:34:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:34:30 (#:amount 96461192 #:time 350))
(heartbeat 2015-08-18T19:34:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:34:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:34:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:35:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:35:59 (#:amount 93144576 #:time 347))
(heartbeat 2015-08-18T19:36:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:36:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:36:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:36:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:36:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:36:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:37:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:37:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:37:24 (#:amount 96344536 #:time 296))
(heartbeat 2015-08-18T19:37:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:37:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:37:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:37:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:38:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:38:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:38:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:38:30 (#:amount 93034968 #:time 348))
(heartbeat 2015-08-18T19:38:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:38:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:38:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:39:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:40:01 (#:amount 96422368 #:time 356))
(heartbeat 2015-08-18T19:40:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:40:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:40:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:40:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:40:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:40:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:41:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:41:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:41:24 (#:amount 93335368 #:time 345))
(heartbeat 2015-08-18T19:41:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:41:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:41:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:41:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:42:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:42:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:42:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:42:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:42:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:42:53 (#:amount 96010600 #:time 357))
(heartbeat 2015-08-18T19:42:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:43:57 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T19:44:03 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -6) #:iterations 221765 #:time 3151841))
(new-average 2015-08-18T19:44:03 (#:model "stlc-sub-3" #:type enum #:average 1836420.4285714284 #:stderr 423661.4372670513))
(heartbeat 2015-08-18T19:44:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:44:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:44:21 (#:amount 92927160 #:time 351))
(heartbeat 2015-08-18T19:44:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:44:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:44:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:44:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:45:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:45:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:45:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:45:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:45:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:45:52 (#:amount 96739240 #:time 357))
(heartbeat 2015-08-18T19:45:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:46:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:47:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:47:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:47:22 (#:amount 92885056 #:time 354))
(heartbeat 2015-08-18T19:47:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:47:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:47:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:47:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:48:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:48:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:48:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:48:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:48:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:48:48 (#:amount 96745496 #:time 344))
(heartbeat 2015-08-18T19:48:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:49:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:50:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:50:08 (#:amount 93123616 #:time 344))
(heartbeat 2015-08-18T19:50:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:50:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:50:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:50:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:50:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:51:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:51:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:51:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:51:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:51:38 (#:amount 96228392 #:time 355))
(heartbeat 2015-08-18T19:51:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:51:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:52:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:53:08 (#:amount 93111968 #:time 347))
(heartbeat 2015-08-18T19:53:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:53:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:53:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:53:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:53:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:53:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:54:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:54:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:54:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:54:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:54:39 (#:amount 96436024 #:time 351))
(heartbeat 2015-08-18T19:54:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:54:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:55:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:56:07 (#:amount 93177872 #:time 348))
(heartbeat 2015-08-18T19:56:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:56:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:56:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:56:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:56:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:56:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:57:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:57:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:57:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:57:37 (#:amount 96220944 #:time 353))
(heartbeat 2015-08-18T19:57:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:57:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:57:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:58:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T19:59:05 (#:amount 93149824 #:time 344))
(heartbeat 2015-08-18T19:59:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:59:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:59:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:59:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:59:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T19:59:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:00:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:00:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:00:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:00:36 (#:amount 96196712 #:time 354))
(heartbeat 2015-08-18T20:00:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:00:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:00:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:01:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:02:05 (#:amount 93036456 #:time 349))
(heartbeat 2015-08-18T20:02:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:02:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:02:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:02:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:02:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:02:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:03:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:03:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:03:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:03:34 (#:amount 96586680 #:time 353))
(heartbeat 2015-08-18T20:03:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:03:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:03:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:04:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:05:01 (#:amount 93263680 #:time 344))
(heartbeat 2015-08-18T20:05:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:05:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:05:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:05:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:05:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:05:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:06:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:06:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:06:27 (#:amount 96224768 #:time 348))
(heartbeat 2015-08-18T20:06:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:06:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:06:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:06:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:07:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:07:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:07:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:07:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:07:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:07:53 (#:amount 93135880 #:time 345))
(heartbeat 2015-08-18T20:07:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:08:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:09:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:09:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:09:22 (#:amount 96362912 #:time 348))
(heartbeat 2015-08-18T20:09:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:09:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:09:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:09:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:10:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:10:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:10:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:10:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:10:49 (#:amount 93192688 #:time 344))
(heartbeat 2015-08-18T20:10:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:10:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:11:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:11:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:11:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:11:39 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:11:47 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -125) #:iterations 114797 #:time 1663967))
(new-average 2015-08-18T20:11:47 (#:model "stlc-sub-3" #:type enum #:average 1814863.7499999998 #:stderr 367534.28474282456))
(heartbeat 2015-08-18T20:11:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:11:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:12:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:12:17 (#:amount 96442360 #:time 347))
(heartbeat 2015-08-18T20:12:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:12:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:12:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:12:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:12:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:13:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:13:19 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:13:27 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -111) #:iterations 6959 #:time 100363))
(new-average 2015-08-18T20:13:27 (#:model "stlc-sub-3" #:type enum #:average 1624363.6666666665 #:stderr 375970.25428734237))
(heartbeat 2015-08-18T20:13:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:13:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:13:44 (#:amount 93256840 #:time 345))
(heartbeat 2015-08-18T20:13:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:13:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:14:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:15:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:15:12 (#:amount 96081384 #:time 347))
(heartbeat 2015-08-18T20:15:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:15:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:15:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:15:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:15:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:16:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:16:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:16:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:16:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:16:39 (#:amount 92970840 #:time 345))
(heartbeat 2015-08-18T20:16:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:16:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:17:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:18:08 (#:amount 96798120 #:time 348))
(heartbeat 2015-08-18T20:18:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:18:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:18:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:18:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:18:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:18:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:19:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:19:17 (#:amount 92868088 #:time 294))
(heartbeat 2015-08-18T20:19:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:19:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:19:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:19:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:20:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:20:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:20:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:20:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:20:36 (#:amount 96769408 #:time 348))
(heartbeat 2015-08-18T20:20:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:20:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:21:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:21:51 (#:amount 93275224 #:time 346))
(heartbeat 2015-08-18T20:22:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:22:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:22:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:22:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:22:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:22:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:23:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:23:10 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:23:12 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -64) #:iterations 43581 #:time 585560))
(new-average 2015-08-18T20:23:12 (#:model "stlc-sub-3" #:type enum #:average 1520483.2999999998 #:stderr 351957.435304203))
(gc-major 2015-08-18T20:23:15 (#:amount 96122440 #:time 299))
(heartbeat 2015-08-18T20:23:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:23:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:23:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:23:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:24:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:24:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:24:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:24:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:24:35 (#:amount 93001344 #:time 348))
(heartbeat 2015-08-18T20:24:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:24:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:25:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:25:53 (#:amount 96490000 #:time 352))
(heartbeat 2015-08-18T20:26:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:26:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:26:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:26:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:26:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:26:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:27:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:27:08 (#:amount 93218704 #:time 344))
(heartbeat 2015-08-18T20:27:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:27:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:27:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:27:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:27:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:28:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:28:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:28:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:28:29 (#:amount 96284312 #:time 351))
(heartbeat 2015-08-18T20:28:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:28:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:28:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:29:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:29:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:29:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:29:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:29:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:29:47 (#:amount 92986144 #:time 345))
(heartbeat 2015-08-18T20:29:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:30:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:31:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:31:06 (#:amount 96656320 #:time 301))
(heartbeat 2015-08-18T20:31:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:31:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:31:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:31:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:31:50 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:31:54 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 20) #:iterations 40379 #:time 521614))
(new-average 2015-08-18T20:31:54 (#:model "stlc-sub-3" #:type enum #:average 1429676.9999999998 #:stderr 331054.7814746897))
(heartbeat 2015-08-18T20:32:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:32:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:32:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:32:22 (#:amount 92903952 #:time 292))
(heartbeat 2015-08-18T20:32:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:32:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:32:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:33:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:33:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:33:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:33:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:33:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:33:40 (#:amount 96850904 #:time 348))
(heartbeat 2015-08-18T20:33:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:34:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:34:57 (#:amount 93064400 #:time 344))
(heartbeat 2015-08-18T20:35:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:35:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:35:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:35:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:35:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:35:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:36:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:36:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:36:18 (#:amount 96602960 #:time 298))
(heartbeat 2015-08-18T20:36:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:36:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:36:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:36:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:37:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:37:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:37:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:37:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:37:38 (#:amount 93244512 #:time 344))
(heartbeat 2015-08-18T20:37:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:37:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:38:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:38:59 (#:amount 96374104 #:time 351))
(heartbeat 2015-08-18T20:39:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:39:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:39:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:39:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:39:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:39:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:40:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:40:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:40:17 (#:amount 92989016 #:time 345))
(heartbeat 2015-08-18T20:40:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:40:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:40:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:40:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:41:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:41:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:41:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:41:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:41:38 (#:amount 96502264 #:time 352))
(heartbeat 2015-08-18T20:41:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:41:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:42:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:42:57 (#:amount 92968272 #:time 294))
(heartbeat 2015-08-18T20:43:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:43:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:43:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:43:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:43:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:43:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:44:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:44:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:44:15 (#:amount 96903848 #:time 352))
(heartbeat 2015-08-18T20:44:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:44:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:44:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:44:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:45:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:45:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:45:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:45:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:45:34 (#:amount 92916552 #:time 345))
(heartbeat 2015-08-18T20:45:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:45:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:46:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:46:58 (#:amount 96752608 #:time 299))
(heartbeat 2015-08-18T20:47:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:47:11 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:47:16 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 1020) #:iterations 70677 #:time 923658))
(new-average 2015-08-18T20:47:16 (#:model "stlc-sub-3" #:type enum #:average 1387508.7499999998 #:stderr 305138.03148046724))
(heartbeat 2015-08-18T20:47:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:47:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:47:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:47:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:48:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:48:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:48:12 (#:amount 92726248 #:time 344))
(heartbeat 2015-08-18T20:48:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:48:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:48:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:48:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:49:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:49:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:49:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:49:28 (#:amount 97097904 #:time 299))
(heartbeat 2015-08-18T20:49:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:49:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:49:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:50:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:50:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:50:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:50:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:50:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:50:42 (#:amount 93005528 #:time 292))
(heartbeat 2015-08-18T20:50:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:51:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:51:57 (#:amount 96627128 #:time 352))
(heartbeat 2015-08-18T20:52:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:52:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:52:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:52:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:52:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:52:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:53:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:53:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:53:12 (#:amount 93073752 #:time 294))
(heartbeat 2015-08-18T20:53:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:53:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:53:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:53:51 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T20:53:55 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 6) #:iterations 32286 #:time 399263))
(new-average 2015-08-18T20:53:55 (#:model "stlc-sub-3" #:type enum #:average 1311489.846153846 #:stderr 290798.20646192506))
(heartbeat 2015-08-18T20:54:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:54:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:54:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:54:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:54:31 (#:amount 96359208 #:time 349))
(heartbeat 2015-08-18T20:54:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:54:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:55:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:55:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:55:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:55:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:55:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:55:44 (#:amount 93069808 #:time 295))
(heartbeat 2015-08-18T20:55:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:56:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:57:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:57:08 (#:amount 96385208 #:time 349))
(heartbeat 2015-08-18T20:57:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:57:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:57:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:57:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:57:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:58:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:58:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:58:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:58:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T20:58:37 (#:amount 93045448 #:time 346))
(heartbeat 2015-08-18T20:58:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:58:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T20:59:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:00:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:00:06 (#:amount 96536472 #:time 349))
(heartbeat 2015-08-18T21:00:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:00:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:00:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:00:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:00:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:01:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:01:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:01:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:01:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:01:35 (#:amount 92712184 #:time 344))
(heartbeat 2015-08-18T21:01:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:01:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:02:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:02:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:02:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:02:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:02:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:02:49 (#:amount 97266216 #:time 295))
(heartbeat 2015-08-18T21:02:51 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T21:02:54 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ʚ (((int → (list int)) → ((list int) → int)) → ((int → int) → (list int)))) ((λ (a int) (cons a)) 41)) #:iterations 39820 #:time 539107))
(new-average 2015-08-18T21:02:54 (#:model "stlc-sub-3" #:type enum #:average 1256319.6428571427 #:stderr 274821.4590840053))
(heartbeat 2015-08-18T21:03:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:03:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:03:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:03:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:03:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:03:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:04:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:04:03 (#:amount 92787256 #:time 290))
(heartbeat 2015-08-18T21:04:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:04:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:04:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:04:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:04:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:05:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:05:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:05:20 (#:amount 96995936 #:time 297))
(heartbeat 2015-08-18T21:05:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:05:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:05:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:05:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:06:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:06:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:06:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:06:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:06:36 (#:amount 93164960 #:time 296))
(heartbeat 2015-08-18T21:06:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:06:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:07:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:07:59 (#:amount 96450776 #:time 297))
(heartbeat 2015-08-18T21:08:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:08:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:08:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:08:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:08:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:08:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:09:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:09:07 (#:amount 93186760 #:time 292))
(heartbeat 2015-08-18T21:09:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:09:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:09:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:09:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:09:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:10:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:10:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:10:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:10:28 (#:amount 96421904 #:time 348))
(heartbeat 2015-08-18T21:10:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:10:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:10:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:11:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:11:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:11:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:11:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:11:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:11:48 (#:amount 93181888 #:time 343))
(heartbeat 2015-08-18T21:11:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:12:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:12:55 (#:amount 96637800 #:time 296))
(heartbeat 2015-08-18T21:13:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:13:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:13:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:13:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:13:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:13:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:13:58 (#:amount 92966024 #:time 294))
(heartbeat 2015-08-18T21:14:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:14:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:14:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:14:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:14:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:14:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:15:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:15:02 (#:amount 96590864 #:time 297))
(heartbeat 2015-08-18T21:15:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:15:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:15:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:15:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:15:52 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T21:16:02 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 247) #:iterations 66222 #:time 788236))
(new-average 2015-08-18T21:16:02 (#:model "stlc-sub-3" #:type enum #:average 1225114.0666666667 #:stderr 257740.9121101389))
(heartbeat 2015-08-18T21:16:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:16:07 (#:amount 93055760 #:time 348))
(heartbeat 2015-08-18T21:16:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:16:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:16:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:16:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:16:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:17:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:17:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:17:18 (#:amount 96573328 #:time 297))
(heartbeat 2015-08-18T21:17:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:17:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:17:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:17:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:18:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:18:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:18:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:18:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:18:34 (#:amount 92961944 #:time 295))
(heartbeat 2015-08-18T21:18:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:18:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:19:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:19:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:19:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:19:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:19:41 (#:amount 96644736 #:time 296))
(heartbeat 2015-08-18T21:19:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:19:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:20:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:20:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:20:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:20:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:20:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:20:52 (#:amount 93105472 #:time 294))
(heartbeat 2015-08-18T21:20:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:21:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:22:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:22:07 (#:amount 96493344 #:time 296))
(heartbeat 2015-08-18T21:22:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:22:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:22:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:22:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:22:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:23:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:23:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:23:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:23:29 (#:amount 92962776 #:time 344))
(heartbeat 2015-08-18T21:23:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:23:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:23:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:24:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:24:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:24:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:24:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:24:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:24:47 (#:amount 96487008 #:time 351))
(heartbeat 2015-08-18T21:24:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:25:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:26:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:26:10 (#:amount 93087336 #:time 349))
(heartbeat 2015-08-18T21:26:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:26:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:26:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:26:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:26:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:27:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:27:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:27:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:27:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:27:40 (#:amount 96326448 #:time 351))
(heartbeat 2015-08-18T21:27:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:27:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:28:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:29:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:29:05 (#:amount 93234344 #:time 345))
(heartbeat 2015-08-18T21:29:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:29:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:29:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:29:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:29:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:30:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:30:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:30:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:30:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:30:34 (#:amount 96413968 #:time 351))
(counterexample 2015-08-18T21:30:38 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 47) #:iterations 67671 #:time 876757))
(new-average 2015-08-18T21:30:38 (#:model "stlc-sub-3" #:type enum #:average 1203341.6875 #:stderr 242075.6432357924))
(heartbeat 2015-08-18T21:30:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:30:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:31:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:32:01 (#:amount 93141008 #:time 351))
(heartbeat 2015-08-18T21:32:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:32:13 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T21:32:15 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (p int) ((λ (a (list int)) (λ (a int) a)) nil)) 816787) #:iterations 6682 #:time 96757))
(new-average 2015-08-18T21:32:15 (#:model "stlc-sub-3" #:type enum #:average 1138248.4117647058 #:stderr 236523.91285667045))
(heartbeat 2015-08-18T21:32:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:32:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:32:43 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T21:32:47 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 454) #:iterations 2203 #:time 31917))
(new-average 2015-08-18T21:32:47 (#:model "stlc-sub-3" #:type enum #:average 1076785.5555555555 #:stderr 231312.11119387756))
(heartbeat 2015-08-18T21:32:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:33:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:33:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:33:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:33:31 (#:amount 96445576 #:time 355))
(heartbeat 2015-08-18T21:33:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:33:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:33:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:34:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:35:01 (#:amount 93152416 #:time 346))
(heartbeat 2015-08-18T21:35:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:35:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:35:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:35:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:35:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:35:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:36:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:36:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:36:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:36:31 (#:amount 96322616 #:time 353))
(heartbeat 2015-08-18T21:36:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:36:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:36:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:37:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:37:59 (#:amount 93184056 #:time 345))
(heartbeat 2015-08-18T21:38:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:38:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:38:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:38:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:38:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:38:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:39:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:39:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:39:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:39:26 (#:amount 96282240 #:time 349))
(heartbeat 2015-08-18T21:39:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:39:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:39:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:40:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:40:53 (#:amount 93170168 #:time 347))
(heartbeat 2015-08-18T21:41:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:41:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:41:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:41:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:41:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:41:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:42:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:42:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:42:21 (#:amount 96143608 #:time 351))
(heartbeat 2015-08-18T21:42:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:42:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:42:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:42:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:43:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:43:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:43:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:43:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:43:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:43:51 (#:amount 93087240 #:time 350))
(heartbeat 2015-08-18T21:43:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:44:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:45:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:45:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:45:21 (#:amount 96525720 #:time 353))
(heartbeat 2015-08-18T21:45:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:45:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:45:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:45:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:46:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:46:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:46:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:46:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:46:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:46:50 (#:amount 93134848 #:time 346))
(heartbeat 2015-08-18T21:46:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:47:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:48:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:48:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:48:14 (#:amount 96301240 #:time 351))
(heartbeat 2015-08-18T21:48:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:48:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:48:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:48:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:49:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:49:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:49:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:49:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:49:43 (#:amount 93125320 #:time 351))
(heartbeat 2015-08-18T21:49:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:49:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:50:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:51:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:51:08 (#:amount 96309336 #:time 350))
(heartbeat 2015-08-18T21:51:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:51:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:51:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:51:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:51:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:52:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:52:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:52:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:52:29 (#:amount 93073000 #:time 343))
(heartbeat 2015-08-18T21:52:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:52:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:52:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:53:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:53:57 (#:amount 96426704 #:time 350))
(heartbeat 2015-08-18T21:54:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:54:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:54:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:54:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:54:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:54:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:55:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:55:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:55:23 (#:amount 93118816 #:time 347))
(heartbeat 2015-08-18T21:55:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:55:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:55:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:55:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:56:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:56:55 (#:amount 96329872 #:time 354))
(heartbeat 2015-08-18T21:57:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:57:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:57:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:57:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:57:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:57:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:58:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:58:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:58:17 (#:amount 93236352 #:time 344))
(heartbeat 2015-08-18T21:58:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:58:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:58:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:58:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:59:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:59:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:59:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T21:59:30 (#:amount 96093072 #:time 293))
(heartbeat 2015-08-18T21:59:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:59:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T21:59:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:00:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:00:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:00:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:00:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:00:41 (#:amount 93185904 #:time 293))
(heartbeat 2015-08-18T22:00:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:00:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:01:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:02:01 (#:amount 96428544 #:time 350))
(heartbeat 2015-08-18T22:02:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:02:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:02:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:02:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:02:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:02:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:03:04 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T22:03:11 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (؉ ((((list int) → (list int)) → ((list int) → (int → int))) → ((int → (list int)) → ((list int) → int)))) ((λ (a int) (cons a)) 28)) #:iterations 129893 #:time 1824411))
(new-average 2015-08-18T22:03:11 (#:model "stlc-sub-3" #:type enum #:average 1116134.2105263157 #:stderr 222309.40904592496))
(heartbeat 2015-08-18T22:03:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:03:19 (#:amount 93005496 #:time 298))
(heartbeat 2015-08-18T22:03:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:03:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:03:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:03:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:04:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:04:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:04:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:04:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:04:43 (#:amount 96755040 #:time 297))
(heartbeat 2015-08-18T22:04:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:04:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:05:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:06:01 (#:amount 92989056 #:time 296))
(heartbeat 2015-08-18T22:06:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:06:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:06:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:06:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:06:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:06:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:07:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:07:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:07:23 (#:amount 96536048 #:time 298))
(heartbeat 2015-08-18T22:07:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:07:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:07:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:07:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:08:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:08:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:08:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:08:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:08:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:08:46 (#:amount 93323888 #:time 318))
(heartbeat 2015-08-18T22:08:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:09:54 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T22:09:57 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) ((λ (a int) a) a)) 391) #:iterations 30608 #:time 406750))
(new-average 2015-08-18T22:09:57 (#:model "stlc-sub-3" #:type enum #:average 1080665.0 #:stderr 213863.019034787))
(gc-major 2015-08-18T22:10:04 (#:amount 96161120 #:time 296))
(heartbeat 2015-08-18T22:10:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:10:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:10:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:10:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:10:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:10:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:11:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:11:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:11:24 (#:amount 93290024 #:time 346))
(heartbeat 2015-08-18T22:11:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:11:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:11:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:11:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:12:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:12:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:12:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:12:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:12:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:12:45 (#:amount 96197960 #:time 299))
(heartbeat 2015-08-18T22:12:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:13:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:14:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:14:10 (#:amount 92919272 #:time 354))
(heartbeat 2015-08-18T22:14:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:14:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:14:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:14:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:14:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:15:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:15:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:15:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:15:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:15:40 (#:amount 96798552 #:time 358))
(heartbeat 2015-08-18T22:15:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:15:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:16:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:17:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:17:08 (#:amount 92973488 #:time 349))
(heartbeat 2015-08-18T22:17:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:17:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:17:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:17:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:17:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:18:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:18:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:18:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:18:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:18:38 (#:amount 96612744 #:time 349))
(heartbeat 2015-08-18T22:18:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:18:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:19:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:20:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:20:06 (#:amount 93245936 #:time 345))
(heartbeat 2015-08-18T22:20:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:20:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:20:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:20:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:20:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:21:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:21:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:21:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:21:32 (#:amount 96272704 #:time 350))
(heartbeat 2015-08-18T22:21:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:21:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:21:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:22:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:23:00 (#:amount 93229296 #:time 347))
(heartbeat 2015-08-18T22:23:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:23:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:23:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:23:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:23:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:23:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:24:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:24:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:24:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:24:32 (#:amount 96217360 #:time 353))
(heartbeat 2015-08-18T22:24:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:24:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:24:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:25:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:26:01 (#:amount 92893208 #:time 344))
(heartbeat 2015-08-18T22:26:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:26:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:26:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:26:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:26:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:26:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:27:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:27:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:27:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:27:29 (#:amount 96789784 #:time 349))
(heartbeat 2015-08-18T22:27:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:27:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:27:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:28:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:28:58 (#:amount 93035368 #:time 346))
(heartbeat 2015-08-18T22:29:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:29:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:29:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:29:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:29:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:29:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:30:05 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T22:30:10 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ۻ ((((list int) → int) → (int → (int → int))) → ((int → (list int)) → (int → (int → int))))) ((λ (a int) (cons a)) 117)) #:iterations 84687 #:time 1212549))
(new-average 2015-08-18T22:30:10 (#:model "stlc-sub-3" #:type enum #:average 1086945.1904761905 #:stderr 203521.22668556758))
(heartbeat 2015-08-18T22:30:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:30:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:30:27 (#:amount 96685048 #:time 351))
(heartbeat 2015-08-18T22:30:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:30:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:30:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:31:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:31:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:31:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:31:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:31:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:31:55 (#:amount 93184552 #:time 347))
(heartbeat 2015-08-18T22:31:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:32:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:33:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:33:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:33:22 (#:amount 96341440 #:time 349))
(heartbeat 2015-08-18T22:33:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:33:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:33:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:33:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:34:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:34:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:34:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:34:29 (#:amount 92939240 #:time 294))
(heartbeat 2015-08-18T22:34:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:34:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:34:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:35:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:35:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:35:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:35:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:35:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:35:46 (#:amount 96943136 #:time 350))
(heartbeat 2015-08-18T22:35:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:36:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:37:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:37:06 (#:amount 93213504 #:time 348))
(heartbeat 2015-08-18T22:37:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:37:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:37:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:37:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:37:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:38:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:38:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:38:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:38:31 (#:amount 96214048 #:time 354))
(heartbeat 2015-08-18T22:38:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:38:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:38:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:39:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:40:01 (#:amount 93288328 #:time 352))
(heartbeat 2015-08-18T22:40:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:40:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:40:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:40:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:40:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:40:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:41:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:41:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:41:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:41:34 (#:amount 96252808 #:time 352))
(heartbeat 2015-08-18T22:41:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:41:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:41:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:42:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:42:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:42:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:42:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:42:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:42:53 (#:amount 93233360 #:time 343))
(heartbeat 2015-08-18T22:42:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:43:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:44:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:44:13 (#:amount 96130032 #:time 350))
(heartbeat 2015-08-18T22:44:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:44:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:44:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:44:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:44:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:45:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:45:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:45:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:45:31 (#:amount 92903288 #:time 346))
(heartbeat 2015-08-18T22:45:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:45:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:45:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:46:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:46:58 (#:amount 96678248 #:time 350))
(heartbeat 2015-08-18T22:47:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:47:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:47:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:47:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:47:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:47:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:48:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:48:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:48:25 (#:amount 93118560 #:time 346))
(heartbeat 2015-08-18T22:48:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:48:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:48:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:48:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:49:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:49:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:49:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:49:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:49:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:49:54 (#:amount 96383464 #:time 346))
(heartbeat 2015-08-18T22:49:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:50:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:51:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:51:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:51:22 (#:amount 93193752 #:time 347))
(heartbeat 2015-08-18T22:51:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:51:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:51:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:51:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:52:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:52:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:52:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:52:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:52:46 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T22:52:47 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -497) #:iterations 98316 #:time 1358064))
(new-average 2015-08-18T22:52:47 (#:model "stlc-sub-3" #:type enum #:average 1099268.7727272727 #:stderr 194440.80066377597))
(gc-major 2015-08-18T22:52:50 (#:amount 96337592 #:time 348))
(heartbeat 2015-08-18T22:52:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:53:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:54:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:54:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:54:18 (#:amount 93284608 #:time 343))
(heartbeat 2015-08-18T22:54:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:54:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:54:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:54:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:55:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:55:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:55:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:55:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:55:39 (#:amount 95974160 #:time 347))
(heartbeat 2015-08-18T22:55:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:55:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:56:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:57:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:57:07 (#:amount 92927816 #:time 350))
(heartbeat 2015-08-18T22:57:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:57:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:57:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:57:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:57:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:58:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:58:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:58:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:58:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T22:58:38 (#:amount 96696568 #:time 353))
(heartbeat 2015-08-18T22:58:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:58:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T22:59:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:00:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:00:07 (#:amount 93137336 #:time 348))
(heartbeat 2015-08-18T23:00:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:00:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:00:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:00:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:00:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:01:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:01:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:01:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:01:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:01:39 (#:amount 96376368 #:time 355))
(heartbeat 2015-08-18T23:01:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:01:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:02:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:03:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:03:08 (#:amount 93252344 #:time 348))
(heartbeat 2015-08-18T23:03:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:03:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:03:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:03:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:03:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:04:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:04:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:04:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:04:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:04:40 (#:amount 96431784 #:time 353))
(heartbeat 2015-08-18T23:04:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:04:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:05:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:06:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:06:10 (#:amount 93129952 #:time 350))
(heartbeat 2015-08-18T23:06:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:06:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:06:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:06:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:06:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:07:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:07:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:07:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:07:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:07:41 (#:amount 96260104 #:time 352))
(heartbeat 2015-08-18T23:07:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:07:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:08:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:09:04 (#:amount 93124424 #:time 345))
(heartbeat 2015-08-18T23:09:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:09:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:09:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:09:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:09:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:09:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:10:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:10:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:10:21 (#:amount 96606528 #:time 301))
(heartbeat 2015-08-18T23:10:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:10:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:10:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:10:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:11:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:11:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:11:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:11:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:11:41 (#:amount 92948304 #:time 346))
(heartbeat 2015-08-18T23:11:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:11:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:12:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:13:05 (#:amount 96752168 #:time 348))
(heartbeat 2015-08-18T23:13:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:13:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:13:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:13:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:13:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:13:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:14:06 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T23:14:12 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ū ((((list int) → int) → int) → ((int → (list int)) → (list int)))) ((λ (a int) (cons a)) 54)) #:iterations 90303 #:time 1284035))
(new-average 2015-08-18T23:14:12 (#:model "stlc-sub-3" #:type enum #:average 1107302.0869565217 #:stderr 185968.20782301686))
(heartbeat 2015-08-18T23:14:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:14:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:14:29 (#:amount 93158608 #:time 343))
(heartbeat 2015-08-18T23:14:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:14:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:14:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:15:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:15:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:15:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:15:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:15:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:15:52 (#:amount 96643400 #:time 350))
(heartbeat 2015-08-18T23:15:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:16:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:17:05 (#:amount 93203352 #:time 292))
(heartbeat 2015-08-18T23:17:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:17:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:17:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:17:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:17:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:17:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:18:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:18:14 (#:amount 96291432 #:time 345))
(heartbeat 2015-08-18T23:18:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:18:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:18:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:18:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:18:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:19:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:19:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:19:19 (#:amount 93225144 #:time 293))
(heartbeat 2015-08-18T23:19:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:19:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:19:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:19:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:20:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:20:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:20:24 (#:amount 96381720 #:time 294))
(heartbeat 2015-08-18T23:20:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:20:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:20:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:20:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:21:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:21:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:21:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:21:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:21:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:21:48 (#:amount 93071840 #:time 344))
(heartbeat 2015-08-18T23:21:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:22:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:23:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:23:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:23:18 (#:amount 96505136 #:time 346))
(heartbeat 2015-08-18T23:23:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:23:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:23:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:23:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:24:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:24:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:24:21 (#:amount 93327192 #:time 290))
(heartbeat 2015-08-18T23:24:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:24:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:24:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:24:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:25:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:25:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:25:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:25:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:25:39 (#:amount 96092976 #:time 349))
(heartbeat 2015-08-18T23:25:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:25:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:26:07 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T23:26:14 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -30) #:iterations 58900 #:time 723015))
(new-average 2015-08-18T23:26:14 (#:model "stlc-sub-3" #:type enum #:average 1091290.125 #:stderr 178769.5240242582))
(heartbeat 2015-08-18T23:26:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:26:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:26:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:26:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:26:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:26:57 (#:amount 93364984 #:time 293))
(heartbeat 2015-08-18T23:27:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:27:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:27:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:27:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:27:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:27:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:28:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:28:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:28:19 (#:amount 96162296 #:time 351))
(heartbeat 2015-08-18T23:28:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:28:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:28:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:28:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:29:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:29:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:29:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:29:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:29:40 (#:amount 93117840 #:time 342))
(heartbeat 2015-08-18T23:29:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:29:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:30:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:31:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:31:08 (#:amount 96474632 #:time 348))
(heartbeat 2015-08-18T23:31:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:31:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:31:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:31:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:31:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:32:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:32:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:32:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:32:36 (#:amount 93055944 #:time 349))
(heartbeat 2015-08-18T23:32:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:32:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:32:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:33:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:34:04 (#:amount 96725352 #:time 352))
(heartbeat 2015-08-18T23:34:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:34:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:34:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:34:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:34:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:34:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:35:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:35:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:35:18 (#:amount 93411704 #:time 295))
(heartbeat 2015-08-18T23:35:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:35:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:35:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:35:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:36:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:36:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:36:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:36:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:36:42 (#:amount 95940160 #:time 295))
(heartbeat 2015-08-18T23:36:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:36:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:37:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:37:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:37:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:37:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:37:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:37:52 (#:amount 92968552 #:time 345))
(heartbeat 2015-08-18T23:37:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:38:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:39:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:39:14 (#:amount 96724496 #:time 354))
(heartbeat 2015-08-18T23:39:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:39:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:39:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:39:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:39:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:40:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:40:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:40:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:40:29 (#:amount 92951352 #:time 299))
(heartbeat 2015-08-18T23:40:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:40:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:40:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:41:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:41:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:41:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:41:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:41:47 (#:amount 96626544 #:time 350))
(heartbeat 2015-08-18T23:41:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:41:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:42:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:43:00 (#:amount 93264736 #:time 296))
(heartbeat 2015-08-18T23:43:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:43:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:43:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:43:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:43:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:43:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:44:04 (#:amount 96370056 #:time 295))
(heartbeat 2015-08-18T23:44:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:44:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:44:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:44:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:44:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:44:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:45:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:45:15 (#:amount 93050848 #:time 296))
(heartbeat 2015-08-18T23:45:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:45:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:45:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:45:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:45:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:46:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:46:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:46:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:46:33 (#:amount 96630568 #:time 349))
(heartbeat 2015-08-18T23:46:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:46:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:46:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:47:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:47:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:47:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:47:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:47:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:47:50 (#:amount 93275328 #:time 346))
(heartbeat 2015-08-18T23:47:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:48:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:49:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:49:16 (#:amount 96149120 #:time 351))
(heartbeat 2015-08-18T23:49:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:49:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:49:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:49:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:49:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:50:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:50:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:50:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:50:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:50:44 (#:amount 93246032 #:time 346))
(heartbeat 2015-08-18T23:50:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:50:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:51:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:52:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:52:10 (#:amount 96261872 #:time 350))
(heartbeat 2015-08-18T23:52:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:52:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:52:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:52:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:52:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:53:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:53:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:53:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:53:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:53:38 (#:amount 93162680 #:time 350))
(heartbeat 2015-08-18T23:53:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:53:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:54:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:55:06 (#:amount 96361384 #:time 354))
(heartbeat 2015-08-18T23:55:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:55:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:55:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:55:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:55:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:55:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:56:08 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-18T23:56:09 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -513) #:iterations 136304 #:time 1795035))
(new-average 2015-08-18T23:56:09 (#:model "stlc-sub-3" #:type enum #:average 1119439.92 #:stderr 173764.98571580256))
(counterexample 2015-08-18T23:56:16 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 65) #:iterations 727 #:time 7569))
(new-average 2015-08-18T23:56:16 (#:model "stlc-sub-3" #:type enum #:average 1076675.6538461538 #:stderr 172338.08791611146))
(heartbeat 2015-08-18T23:56:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:56:23 (#:amount 93392576 #:time 346))
(heartbeat 2015-08-18T23:56:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:56:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:56:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:56:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:57:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:57:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:57:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:57:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:57:45 (#:amount 96234576 #:time 348))
(heartbeat 2015-08-18T23:57:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:57:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:58:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-18T23:59:05 (#:amount 93154864 #:time 297))
(heartbeat 2015-08-18T23:59:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:59:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:59:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:59:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:59:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-18T23:59:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:00:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:00:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:00:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:00:29 (#:amount 96373584 #:time 351))
(heartbeat 2015-08-19T00:00:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:00:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:00:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:01:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:01:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:01:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:01:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:01:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:01:55 (#:amount 93238816 #:time 351))
(heartbeat 2015-08-19T00:01:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:02:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:03:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:03:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:03:25 (#:amount 96494144 #:time 358))
(heartbeat 2015-08-19T00:03:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:03:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:03:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:03:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:04:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:04:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:04:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:04:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:04:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:04:53 (#:amount 93155760 #:time 347))
(heartbeat 2015-08-19T00:04:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:05:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:06:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:06:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:06:21 (#:amount 96411144 #:time 351))
(heartbeat 2015-08-19T00:06:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:06:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:06:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:06:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:07:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:07:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:07:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:07:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:07:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:07:50 (#:amount 93350760 #:time 350))
(heartbeat 2015-08-19T00:07:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:08:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:09:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:09:17 (#:amount 96187512 #:time 351))
(heartbeat 2015-08-19T00:09:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:09:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:09:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:09:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:09:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:10:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:10:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:10:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:10:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:10:45 (#:amount 93220208 #:time 349))
(heartbeat 2015-08-19T00:10:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:10:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:11:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:12:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:12:14 (#:amount 96171064 #:time 351))
(heartbeat 2015-08-19T00:12:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:12:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:12:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:12:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:12:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:13:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:13:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:13:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:13:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:13:42 (#:amount 93278272 #:time 345))
(heartbeat 2015-08-19T00:13:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:13:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:14:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:15:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:15:12 (#:amount 96183552 #:time 357))
(heartbeat 2015-08-19T00:15:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:15:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:15:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:15:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:15:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:16:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:16:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:16:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:16:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:16:40 (#:amount 93478168 #:time 344))
(heartbeat 2015-08-19T00:16:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:16:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:17:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:17:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:17:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:17:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:17:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:17:55 (#:amount 95982304 #:time 298))
(heartbeat 2015-08-19T00:17:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:18:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:19:04 (#:amount 93206424 #:time 342))
(heartbeat 2015-08-19T00:19:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:19:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:19:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:19:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:19:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:19:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:20:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:20:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:20:25 (#:amount 96300368 #:time 350))
(heartbeat 2015-08-19T00:20:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:20:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:20:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:20:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:21:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:21:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:21:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:21:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:21:42 (#:amount 93145704 #:time 344))
(heartbeat 2015-08-19T00:21:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:21:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:22:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:23:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:23:10 (#:amount 96599768 #:time 349))
(heartbeat 2015-08-19T00:23:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:23:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:23:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:23:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:23:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:24:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:24:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:24:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:24:38 (#:amount 92904632 #:time 348))
(heartbeat 2015-08-19T00:24:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:24:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:24:59 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T00:25:05 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -10) #:iterations 124036 #:time 1727928))
(new-average 2015-08-19T00:25:05 (#:model "stlc-sub-3" #:type enum #:average 1100796.111111111 #:stderr 167577.39152388563))
(heartbeat 2015-08-19T00:25:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:25:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:25:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:25:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:25:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:25:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:26:09 (#:amount 96871576 #:time 299))
(heartbeat 2015-08-19T00:26:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:26:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:26:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:26:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:26:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:26:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:27:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:27:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:27:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:27:37 (#:amount 93242464 #:time 350))
(heartbeat 2015-08-19T00:27:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:27:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:27:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:28:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:29:08 (#:amount 96008056 #:time 352))
(heartbeat 2015-08-19T00:29:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:29:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:29:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:29:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:29:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:29:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:30:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:30:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:30:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:30:36 (#:amount 93167216 #:time 342))
(heartbeat 2015-08-19T00:30:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:30:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:30:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:31:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:31:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:31:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:31:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:31:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:31:49 (#:amount 96368344 #:time 351))
(heartbeat 2015-08-19T00:31:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:32:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:33:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:33:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:33:21 (#:amount 92998000 #:time 343))
(heartbeat 2015-08-19T00:33:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:33:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:33:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:34:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:34:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:34:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:34:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:34:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:34:45 (#:amount 96734144 #:time 350))
(heartbeat 2015-08-19T00:34:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:35:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:36:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:36:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:36:13 (#:amount 92948176 #:time 347))
(heartbeat 2015-08-19T00:36:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:36:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:36:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:36:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:37:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:37:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:37:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:37:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:37:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:37:42 (#:amount 96850784 #:time 349))
(heartbeat 2015-08-19T00:37:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:38:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:39:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:39:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:39:11 (#:amount 93480904 #:time 344))
(heartbeat 2015-08-19T00:39:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:39:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:39:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:39:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:40:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:40:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:40:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:40:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:40:39 (#:amount 95738152 #:time 351))
(heartbeat 2015-08-19T00:40:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:40:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:41:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:42:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:42:08 (#:amount 93076952 #:time 344))
(heartbeat 2015-08-19T00:42:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:42:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:42:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:42:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:42:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:43:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:43:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:43:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:43:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:43:39 (#:amount 96765824 #:time 349))
(heartbeat 2015-08-19T00:43:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:43:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:44:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:45:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:45:07 (#:amount 93286528 #:time 346))
(heartbeat 2015-08-19T00:45:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:45:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:45:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:45:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:45:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:46:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:46:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:46:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:46:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:46:30 (#:amount 96058680 #:time 346))
(heartbeat 2015-08-19T00:46:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:46:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:47:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:47:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:47:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:47:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:47:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:47:49 (#:amount 93356752 #:time 343))
(heartbeat 2015-08-19T00:47:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:48:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:49:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:49:09 (#:amount 96176760 #:time 350))
(heartbeat 2015-08-19T00:49:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:49:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:49:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:49:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:49:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:50:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:50:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:50:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:50:28 (#:amount 92871912 #:time 346))
(heartbeat 2015-08-19T00:50:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:50:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:50:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:51:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:51:51 (#:amount 97012952 #:time 349))
(heartbeat 2015-08-19T00:52:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:52:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:52:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:52:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:52:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:52:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:53:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:53:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:53:17 (#:amount 93131520 #:time 343))
(heartbeat 2015-08-19T00:53:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:53:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:53:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:53:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:54:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:54:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:54:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:54:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:54:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:54:45 (#:amount 96273768 #:time 347))
(heartbeat 2015-08-19T00:54:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:55:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:56:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:56:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:56:12 (#:amount 92986520 #:time 345))
(heartbeat 2015-08-19T00:56:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:56:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:56:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:56:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:57:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:57:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:57:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:57:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:57:40 (#:amount 96665336 #:time 354))
(heartbeat 2015-08-19T00:57:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:57:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:58:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:59:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T00:59:10 (#:amount 93277656 #:time 346))
(heartbeat 2015-08-19T00:59:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:59:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:59:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:59:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T00:59:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:00:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:00:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:00:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:00:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:00:40 (#:amount 96269704 #:time 352))
(heartbeat 2015-08-19T01:00:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:00:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:01:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:02:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:02:09 (#:amount 93295224 #:time 348))
(heartbeat 2015-08-19T01:02:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:02:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:02:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:02:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:02:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:03:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:03:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:03:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:03:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:03:32 (#:amount 96301336 #:time 296))
(heartbeat 2015-08-19T01:03:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:03:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:04:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:05:00 (#:amount 93323584 #:time 347))
(heartbeat 2015-08-19T01:05:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:05:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:05:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:05:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:05:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:05:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:06:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:06:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:06:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:06:29 (#:amount 95922992 #:time 347))
(heartbeat 2015-08-19T01:06:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:06:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:06:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:07:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:07:57 (#:amount 93024368 #:time 350))
(heartbeat 2015-08-19T01:08:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:08:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:08:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:08:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:08:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:08:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:09:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:09:10 (#:amount 96495464 #:time 317))
(heartbeat 2015-08-19T01:09:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:09:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:09:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:09:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:09:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:10:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:10:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:10:19 (#:amount 93097800 #:time 292))
(heartbeat 2015-08-19T01:10:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:10:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:10:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:10:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:11:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:11:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:11:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:11:30 (#:amount 96760480 #:time 299))
(heartbeat 2015-08-19T01:11:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:11:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:11:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:12:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:12:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:12:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:12:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:12:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:12:50 (#:amount 92947168 #:time 349))
(heartbeat 2015-08-19T01:12:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:13:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:14:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:14:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:14:21 (#:amount 96680576 #:time 351))
(heartbeat 2015-08-19T01:14:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:14:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:14:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:14:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:15:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:15:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:15:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:15:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:15:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:15:50 (#:amount 93053112 #:time 346))
(heartbeat 2015-08-19T01:15:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:16:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:17:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:17:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:17:20 (#:amount 96758688 #:time 354))
(heartbeat 2015-08-19T01:17:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:17:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:17:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:17:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:18:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:18:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:18:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:18:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:18:37 (#:amount 93093056 #:time 346))
(heartbeat 2015-08-19T01:18:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:18:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:19:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:20:01 (#:amount 96429800 #:time 351))
(heartbeat 2015-08-19T01:20:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:20:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:20:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:20:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:20:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:20:51 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T01:20:55 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) ((λ (a int) a) a)) -330) #:iterations 239955 #:time 3349226))
(new-average 2015-08-19T01:20:55 (#:model "stlc-sub-3" #:type enum #:average 1181097.1785714284 #:stderr 180345.7053318661))
(heartbeat 2015-08-19T01:21:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:21:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:21:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:21:24 (#:amount 92889984 #:time 347))
(heartbeat 2015-08-19T01:21:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:21:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:21:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:22:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:22:52 (#:amount 97127688 #:time 352))
(heartbeat 2015-08-19T01:23:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:23:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:23:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:23:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:23:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:23:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:24:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:24:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:24:20 (#:amount 93000640 #:time 346))
(heartbeat 2015-08-19T01:24:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:24:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:24:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:24:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:25:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:25:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:25:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:25:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:25:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:25:50 (#:amount 96647880 #:time 352))
(heartbeat 2015-08-19T01:25:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:26:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:27:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:27:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:27:18 (#:amount 93060960 #:time 343))
(heartbeat 2015-08-19T01:27:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:27:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:27:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:27:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:28:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:28:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:28:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:28:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:28:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:28:48 (#:amount 96629328 #:time 351))
(heartbeat 2015-08-19T01:28:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:29:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:30:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:30:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:30:17 (#:amount 93065680 #:time 348))
(heartbeat 2015-08-19T01:30:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:30:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:30:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:30:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:31:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:31:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:31:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:31:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:31:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:31:48 (#:amount 96736968 #:time 351))
(heartbeat 2015-08-19T01:31:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:32:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:33:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:33:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:33:16 (#:amount 93323576 #:time 349))
(heartbeat 2015-08-19T01:33:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:33:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:33:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:33:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:34:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:34:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:34:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:34:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:34:37 (#:amount 96087896 #:time 345))
(heartbeat 2015-08-19T01:34:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:34:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:35:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:35:57 (#:amount 93144760 #:time 342))
(heartbeat 2015-08-19T01:36:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:36:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:36:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:36:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:36:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:36:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:37:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:37:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:37:17 (#:amount 96547368 #:time 350))
(heartbeat 2015-08-19T01:37:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:37:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:37:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:37:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:38:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:38:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:38:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:38:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:38:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:38:44 (#:amount 93452528 #:time 345))
(heartbeat 2015-08-19T01:38:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:39:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:40:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:40:10 (#:amount 95941776 #:time 349))
(heartbeat 2015-08-19T01:40:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:40:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:40:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:40:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:40:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:41:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:41:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:41:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:41:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:41:37 (#:amount 93015168 #:time 347))
(heartbeat 2015-08-19T01:41:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:41:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:42:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:43:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:43:04 (#:amount 96810120 #:time 350))
(heartbeat 2015-08-19T01:43:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:43:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:43:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:43:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:43:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:44:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:44:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:44:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:44:30 (#:amount 93085768 #:time 346))
(heartbeat 2015-08-19T01:44:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:44:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:44:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:45:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:45:58 (#:amount 96458360 #:time 351))
(heartbeat 2015-08-19T01:46:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:46:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:46:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:46:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:46:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:46:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:47:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:47:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:47:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:47:27 (#:amount 93299032 #:time 346))
(heartbeat 2015-08-19T01:47:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:47:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:47:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:48:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:48:52 (#:amount 96276432 #:time 350))
(heartbeat 2015-08-19T01:49:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:49:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:49:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:49:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:49:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:49:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:50:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:50:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:50:19 (#:amount 93339088 #:time 347))
(heartbeat 2015-08-19T01:50:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:50:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:50:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:50:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:51:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:51:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:51:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:51:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:51:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:51:43 (#:amount 96248408 #:time 350))
(heartbeat 2015-08-19T01:51:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:52:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:53:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:53:11 (#:amount 93236616 #:time 349))
(heartbeat 2015-08-19T01:53:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:53:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:53:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:53:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:53:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:54:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:54:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:54:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:54:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:54:37 (#:amount 96572656 #:time 352))
(heartbeat 2015-08-19T01:54:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:54:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:55:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:56:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:56:06 (#:amount 93177448 #:time 350))
(heartbeat 2015-08-19T01:56:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:56:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:56:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:56:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:56:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:57:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:57:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:57:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:57:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:57:34 (#:amount 96507760 #:time 355))
(heartbeat 2015-08-19T01:57:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:57:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:58:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:59:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T01:59:04 (#:amount 93182976 #:time 347))
(heartbeat 2015-08-19T01:59:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:59:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:59:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:59:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T01:59:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:00:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:00:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:00:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:00:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:00:34 (#:amount 96514392 #:time 353))
(heartbeat 2015-08-19T02:00:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:00:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:01:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:02:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:02:04 (#:amount 93253976 #:time 346))
(heartbeat 2015-08-19T02:02:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:02:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:02:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:02:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:02:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:03:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:03:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:03:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:03:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:03:34 (#:amount 96386664 #:time 351))
(heartbeat 2015-08-19T02:03:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:03:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:04:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:05:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:05:03 (#:amount 93347864 #:time 347))
(heartbeat 2015-08-19T02:05:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:05:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:05:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:05:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:05:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:06:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:06:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:06:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:06:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:06:34 (#:amount 96216808 #:time 355))
(heartbeat 2015-08-19T02:06:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:06:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:07:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:08:03 (#:amount 93157088 #:time 347))
(heartbeat 2015-08-19T02:08:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:08:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:08:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:08:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:08:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:08:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:09:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:09:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:09:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:09:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:09:34 (#:amount 96435768 #:time 351))
(heartbeat 2015-08-19T02:09:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:09:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:10:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:11:02 (#:amount 92745136 #:time 352))
(heartbeat 2015-08-19T02:11:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:11:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:11:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:11:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:11:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:11:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:12:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:12:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:12:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:12:30 (#:amount 97293392 #:time 353))
(heartbeat 2015-08-19T02:12:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:12:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:12:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:13:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:13:58 (#:amount 93231464 #:time 292))
(heartbeat 2015-08-19T02:14:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:14:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:14:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:14:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:14:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:14:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:15:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:15:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:15:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:15:27 (#:amount 96331776 #:time 342))
(heartbeat 2015-08-19T02:15:33 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T02:15:41 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) ((λ (a int) a) a)) 364) #:iterations 228695 #:time 3285375))
(new-average 2015-08-19T02:15:41 (#:model "stlc-sub-3" #:type enum #:average 1253658.4827586205 #:stderr 188538.17191016165))
(heartbeat 2015-08-19T02:15:43 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T02:15:49 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ϼ ((int → (list int)) → ((list int) → ((list int) → (list int))))) ((λ (a int) (cons a)) -59)) #:iterations 552 #:time 8132))
(new-average 2015-08-19T02:15:49 (#:model "stlc-sub-3" #:type enum #:average 1212140.933333333 #:stderr 186816.95058628503))
(heartbeat 2015-08-19T02:15:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:16:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:16:55 (#:amount 92973792 #:time 349))
(heartbeat 2015-08-19T02:17:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:17:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:17:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:17:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:17:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:17:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:18:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:18:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:18:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:18:23 (#:amount 96875048 #:time 352))
(heartbeat 2015-08-19T02:18:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:18:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:18:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:19:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:19:54 (#:amount 93266600 #:time 349))
(heartbeat 2015-08-19T02:20:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:20:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:20:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:20:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:20:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:20:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:21:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:21:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:21:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:21:26 (#:amount 96420800 #:time 353))
(heartbeat 2015-08-19T02:21:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:21:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:21:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:22:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:22:57 (#:amount 93189768 #:time 351))
(heartbeat 2015-08-19T02:23:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:23:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:23:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:23:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:23:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:23:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:24:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:24:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:24:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:24:25 (#:amount 96403200 #:time 351))
(heartbeat 2015-08-19T02:24:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:24:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:24:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:25:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:25:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:25:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:25:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:25:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:25:50 (#:amount 93445096 #:time 346))
(heartbeat 2015-08-19T02:25:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:26:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:27:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:27:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:27:18 (#:amount 96129880 #:time 350))
(heartbeat 2015-08-19T02:27:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:27:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:27:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:27:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:28:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:28:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:28:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:28:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:28:42 (#:amount 93114336 #:time 344))
(heartbeat 2015-08-19T02:28:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:28:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:29:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:30:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:30:13 (#:amount 96596304 #:time 351))
(heartbeat 2015-08-19T02:30:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:30:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:30:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:30:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:30:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:31:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:31:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:31:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:31:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:31:40 (#:amount 93225536 #:time 346))
(heartbeat 2015-08-19T02:31:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:31:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:32:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:33:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:33:08 (#:amount 96498608 #:time 348))
(heartbeat 2015-08-19T02:33:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:33:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:33:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:33:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:33:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:34:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:34:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:34:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:34:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:34:36 (#:amount 93185024 #:time 347))
(heartbeat 2015-08-19T02:34:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:34:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:35:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:36:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:36:05 (#:amount 96387248 #:time 349))
(heartbeat 2015-08-19T02:36:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:36:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:36:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:36:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:36:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:37:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:37:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:37:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:37:32 (#:amount 93339424 #:time 348))
(heartbeat 2015-08-19T02:37:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:37:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:37:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:38:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:38:58 (#:amount 96256832 #:time 298))
(heartbeat 2015-08-19T02:39:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:39:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:39:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:39:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:39:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:39:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:40:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:40:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:40:23 (#:amount 93107312 #:time 307))
(heartbeat 2015-08-19T02:40:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:40:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:40:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:40:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:41:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:41:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:41:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:41:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:41:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:41:48 (#:amount 96583712 #:time 351))
(heartbeat 2015-08-19T02:41:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:42:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:43:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:43:11 (#:amount 93369296 #:time 342))
(heartbeat 2015-08-19T02:43:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:43:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:43:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:43:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:43:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:44:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:44:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:44:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:44:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:44:35 (#:amount 96254000 #:time 349))
(heartbeat 2015-08-19T02:44:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:44:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:45:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:45:58 (#:amount 93190736 #:time 347))
(heartbeat 2015-08-19T02:46:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:46:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:46:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:46:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:46:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:46:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:47:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:47:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:47:20 (#:amount 96449144 #:time 351))
(heartbeat 2015-08-19T02:47:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:47:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:47:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:47:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:48:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:48:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:48:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:48:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:48:39 (#:amount 92841976 #:time 346))
(heartbeat 2015-08-19T02:48:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:48:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:49:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:50:00 (#:amount 97055144 #:time 297))
(heartbeat 2015-08-19T02:50:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:50:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:50:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:50:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:50:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:50:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:51:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:51:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:51:17 (#:amount 92967960 #:time 295))
(heartbeat 2015-08-19T02:51:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:51:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:51:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:51:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:52:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:52:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:52:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:52:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:52:35 (#:amount 96728568 #:time 353))
(heartbeat 2015-08-19T02:52:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:52:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:53:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:54:01 (#:amount 93244072 #:time 347))
(counterexample 2015-08-19T02:54:02 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 137) #:iterations 162950 #:time 2293508))
(new-average 2015-08-19T02:54:02 (#:model "stlc-sub-3" #:type enum #:average 1247023.7419354836 #:stderr 184026.44779939772))
(heartbeat 2015-08-19T02:54:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:54:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:54:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:54:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:54:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:54:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:55:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:55:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:55:19 (#:amount 96423064 #:time 298))
(heartbeat 2015-08-19T02:55:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:55:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:55:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:55:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:56:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:56:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:56:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:56:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:56:36 (#:amount 92999824 #:time 323))
(heartbeat 2015-08-19T02:56:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:56:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:57:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:57:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:57:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:57:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:57:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:57:54 (#:amount 96690872 #:time 295))
(heartbeat 2015-08-19T02:57:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:58:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:59:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T02:59:15 (#:amount 93121552 #:time 349))
(heartbeat 2015-08-19T02:59:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:59:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:59:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:59:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T02:59:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:00:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:00:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:00:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:00:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:00:37 (#:amount 96577296 #:time 349))
(heartbeat 2015-08-19T03:00:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:00:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:01:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:02:02 (#:amount 93016920 #:time 345))
(heartbeat 2015-08-19T03:02:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:02:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:02:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:02:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:02:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:02:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:03:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:03:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:03:17 (#:amount 96862072 #:time 351))
(heartbeat 2015-08-19T03:03:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:03:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:03:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:03:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:04:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:04:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:04:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:04:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:04:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:04:46 (#:amount 93312184 #:time 349))
(heartbeat 2015-08-19T03:04:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:05:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:05:15 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T03:05:24 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 44) #:iterations 51079 #:time 682126))
(new-average 2015-08-19T03:05:24 (#:model "stlc-sub-3" #:type enum #:average 1229370.6874999998 #:stderr 179055.17439454957))
(heartbeat 2015-08-19T03:05:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:05:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:05:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:05:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:06:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:06:10 (#:amount 96218248 #:time 297))
(heartbeat 2015-08-19T03:06:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:06:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:06:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:06:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:06:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:07:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:07:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:07:21 (#:amount 92960656 #:time 348))
(heartbeat 2015-08-19T03:07:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:07:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:07:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:07:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:08:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:08:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:08:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:08:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:08:45 (#:amount 96722976 #:time 350))
(heartbeat 2015-08-19T03:08:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:08:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:09:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:10:04 (#:amount 93009576 #:time 344))
(heartbeat 2015-08-19T03:10:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:10:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:10:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:10:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:10:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:10:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:11:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:11:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:11:25 (#:amount 96731088 #:time 353))
(heartbeat 2015-08-19T03:11:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:11:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:11:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:11:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:12:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:12:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:12:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:12:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:12:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:12:54 (#:amount 93323432 #:time 346))
(heartbeat 2015-08-19T03:12:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:13:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:14:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:14:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:14:22 (#:amount 96319504 #:time 298))
(heartbeat 2015-08-19T03:14:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:14:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:14:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:14:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:15:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:15:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:15:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:15:34 (#:amount 93215216 #:time 298))
(heartbeat 2015-08-19T03:15:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:15:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:15:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:16:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:16:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:16:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:16:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:16:39 (#:amount 96600072 #:time 299))
(heartbeat 2015-08-19T03:16:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:16:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:17:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:17:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:17:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:17:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:17:42 (#:amount 93252248 #:time 297))
(heartbeat 2015-08-19T03:17:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:17:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:18:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:19:05 (#:amount 96521544 #:time 352))
(heartbeat 2015-08-19T03:19:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:19:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:19:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:19:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:19:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:19:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:20:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:20:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:20:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:20:32 (#:amount 93273536 #:time 351))
(heartbeat 2015-08-19T03:20:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:20:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:20:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:21:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:21:59 (#:amount 96343104 #:time 350))
(heartbeat 2015-08-19T03:22:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:22:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:22:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:22:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:22:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:22:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:23:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:23:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:23:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:23:26 (#:amount 93391072 #:time 344))
(heartbeat 2015-08-19T03:23:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:23:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:23:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:24:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:24:58 (#:amount 96246208 #:time 351))
(heartbeat 2015-08-19T03:25:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:25:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:25:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:25:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:25:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:25:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:26:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:26:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:26:20 (#:amount 93236808 #:time 301))
(heartbeat 2015-08-19T03:26:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:26:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:26:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:26:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:27:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:27:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:27:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:27:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:27:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:27:48 (#:amount 96420680 #:time 346))
(heartbeat 2015-08-19T03:27:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:28:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:29:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:29:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:29:17 (#:amount 93259384 #:time 350))
(heartbeat 2015-08-19T03:29:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:29:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:29:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:29:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:30:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:30:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:30:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:30:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:30:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:30:46 (#:amount 96516104 #:time 300))
(heartbeat 2015-08-19T03:30:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:31:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:32:06 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T03:32:08 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -170) #:iterations 118873 #:time 1604488))
(new-average 2015-08-19T03:32:08 (#:model "stlc-sub-3" #:type enum #:average 1240737.8787878787 #:stderr 173916.33743180832))
(gc-major 2015-08-19T03:32:15 (#:amount 93048104 #:time 348))
(heartbeat 2015-08-19T03:32:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:32:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:32:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:32:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:32:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:33:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:33:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:33:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:33:33 (#:amount 96696728 #:time 299))
(heartbeat 2015-08-19T03:33:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:33:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:33:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:34:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:34:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:34:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:34:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:34:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:34:49 (#:amount 93272064 #:time 345))
(heartbeat 2015-08-19T03:34:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:35:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:36:06 (#:amount 96232568 #:time 354))
(heartbeat 2015-08-19T03:36:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:36:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:36:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:36:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:36:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:36:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:37:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:37:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:37:26 (#:amount 93017784 #:time 297))
(heartbeat 2015-08-19T03:37:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:37:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:37:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:37:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:38:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:38:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:38:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:38:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:38:46 (#:amount 96868328 #:time 351))
(heartbeat 2015-08-19T03:38:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:38:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:39:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:40:04 (#:amount 93091528 #:time 347))
(heartbeat 2015-08-19T03:40:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:40:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:40:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:40:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:40:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:40:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:41:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:41:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:41:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:41:34 (#:amount 96635136 #:time 356))
(heartbeat 2015-08-19T03:41:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:41:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:41:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:42:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:43:03 (#:amount 93364840 #:time 346))
(heartbeat 2015-08-19T03:43:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:43:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:43:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:43:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:43:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:43:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:44:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:44:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:44:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:44:33 (#:amount 96389632 #:time 353))
(heartbeat 2015-08-19T03:44:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:44:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:44:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:45:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:46:02 (#:amount 93346936 #:time 352))
(heartbeat 2015-08-19T03:46:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:46:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:46:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:46:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:46:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:46:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:47:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:47:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:47:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:47:32 (#:amount 96165464 #:time 356))
(heartbeat 2015-08-19T03:47:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:47:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:47:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:48:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:49:01 (#:amount 93251056 #:time 350))
(heartbeat 2015-08-19T03:49:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:49:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:49:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:49:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:49:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:49:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:50:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:50:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:50:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:50:30 (#:amount 96447928 #:time 353))
(heartbeat 2015-08-19T03:50:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:50:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:50:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:51:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:51:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:51:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:51:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:51:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:51:55 (#:amount 93078208 #:time 348))
(heartbeat 2015-08-19T03:51:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:52:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:53:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:53:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:53:26 (#:amount 96834984 #:time 353))
(heartbeat 2015-08-19T03:53:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:53:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:53:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:53:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:54:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:54:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:54:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:54:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:54:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:54:56 (#:amount 93120792 #:time 350))
(heartbeat 2015-08-19T03:54:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:55:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:56:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:56:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:56:21 (#:amount 96619744 #:time 346))
(heartbeat 2015-08-19T03:56:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:56:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:56:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:56:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:57:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:57:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:57:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:57:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:57:46 (#:amount 93337032 #:time 344))
(heartbeat 2015-08-19T03:57:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:57:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:58:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:59:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T03:59:14 (#:amount 96398632 #:time 348))
(heartbeat 2015-08-19T03:59:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:59:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:59:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:59:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T03:59:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:00:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:00:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:00:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:00:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:00:41 (#:amount 93382328 #:time 351))
(heartbeat 2015-08-19T04:00:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:00:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:01:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:02:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:02:11 (#:amount 96266024 #:time 347))
(heartbeat 2015-08-19T04:02:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:02:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:02:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:02:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:02:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:03:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:03:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:03:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:03:30 (#:amount 93063912 #:time 345))
(heartbeat 2015-08-19T04:03:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:03:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:03:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:04:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:04:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:04:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:04:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:04:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:04:49 (#:amount 96631080 #:time 357))
(heartbeat 2015-08-19T04:04:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:05:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:06:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:06:08 (#:amount 93461336 #:time 348))
(heartbeat 2015-08-19T04:06:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:06:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:06:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:06:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:06:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:07:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:07:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:07:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:07:28 (#:amount 96209560 #:time 348))
(heartbeat 2015-08-19T04:07:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:07:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:07:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:08:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:08:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:08:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:08:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:08:46 (#:amount 93038512 #:time 348))
(heartbeat 2015-08-19T04:08:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:08:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:09:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:10:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:10:10 (#:amount 96754896 #:time 325))
(heartbeat 2015-08-19T04:10:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:10:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:10:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:10:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:10:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:11:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:11:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:11:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:11:36 (#:amount 93304984 #:time 348))
(heartbeat 2015-08-19T04:11:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:11:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:11:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:12:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:13:00 (#:amount 96331264 #:time 361))
(heartbeat 2015-08-19T04:13:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:13:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:13:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:13:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:13:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:13:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:14:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:14:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:14:28 (#:amount 93206528 #:time 348))
(heartbeat 2015-08-19T04:14:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:14:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:14:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:14:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:15:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:15:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:15:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:15:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:15:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:15:55 (#:amount 96569600 #:time 354))
(heartbeat 2015-08-19T04:15:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:16:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:17:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:17:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:17:24 (#:amount 93035216 #:time 349))
(heartbeat 2015-08-19T04:17:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:17:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:17:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:17:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:18:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:18:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:18:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:18:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:18:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:18:53 (#:amount 96881944 #:time 352))
(heartbeat 2015-08-19T04:18:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:19:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:20:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:20:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:20:21 (#:amount 93496424 #:time 347))
(heartbeat 2015-08-19T04:20:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:20:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:20:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:20:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:21:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:21:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:21:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:21:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:21:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:21:51 (#:amount 95970736 #:time 352))
(heartbeat 2015-08-19T04:21:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:22:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:23:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:23:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:23:20 (#:amount 93233376 #:time 350))
(heartbeat 2015-08-19T04:23:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:23:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:23:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:23:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:24:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:24:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:24:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:24:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:24:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:24:49 (#:amount 96468648 #:time 352))
(heartbeat 2015-08-19T04:24:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:25:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:26:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:26:10 (#:amount 93168024 #:time 347))
(heartbeat 2015-08-19T04:26:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:26:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:26:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:26:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:26:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:27:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:27:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:27:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:27:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:27:39 (#:amount 96584448 #:time 351))
(heartbeat 2015-08-19T04:27:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:27:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:28:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:29:07 (#:amount 93126568 #:time 347))
(heartbeat 2015-08-19T04:29:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:29:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:29:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:29:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:29:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:29:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:30:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:30:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:30:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:30:37 (#:amount 96901800 #:time 352))
(heartbeat 2015-08-19T04:30:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:30:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:30:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:31:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:32:06 (#:amount 93128704 #:time 347))
(heartbeat 2015-08-19T04:32:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:32:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:32:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:32:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:32:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:32:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:33:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:33:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:33:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:33:36 (#:amount 96884200 #:time 355))
(heartbeat 2015-08-19T04:33:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:33:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:33:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:34:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:35:04 (#:amount 93247744 #:time 350))
(heartbeat 2015-08-19T04:35:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:35:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:35:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:35:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:35:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:35:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:36:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:36:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:36:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:36:30 (#:amount 96288592 #:time 330))
(heartbeat 2015-08-19T04:36:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:36:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:36:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:37:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:37:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:37:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:37:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:37:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:37:49 (#:amount 93262848 #:time 348))
(heartbeat 2015-08-19T04:37:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:38:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:39:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:39:11 (#:amount 96287696 #:time 356))
(heartbeat 2015-08-19T04:39:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:39:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:39:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:39:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:39:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:40:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:40:18 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T04:40:20 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -1) #:iterations 291540 #:time 4093111))
(new-average 2015-08-19T04:40:20 (#:model "stlc-sub-3" #:type enum #:average 1324631.2058823528 #:stderr 188429.7051700122))
(heartbeat 2015-08-19T04:40:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:40:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:40:43 (#:amount 93025448 #:time 353))
(heartbeat 2015-08-19T04:40:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:40:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:41:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:42:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:42:15 (#:amount 96836680 #:time 356))
(heartbeat 2015-08-19T04:42:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:42:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:42:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:42:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:42:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:43:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:43:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:43:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:43:36 (#:amount 93046064 #:time 348))
(heartbeat 2015-08-19T04:43:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:43:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:43:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:44:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:45:02 (#:amount 96780632 #:time 357))
(heartbeat 2015-08-19T04:45:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:45:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:45:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:45:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:45:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:45:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:46:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:46:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:46:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:46:30 (#:amount 93310568 #:time 352))
(heartbeat 2015-08-19T04:46:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:46:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:46:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:47:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:47:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:47:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:47:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:47:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:47:58 (#:amount 96213264 #:time 355))
(heartbeat 2015-08-19T04:47:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:48:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:49:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:49:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:49:25 (#:amount 93220752 #:time 354))
(heartbeat 2015-08-19T04:49:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:49:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:49:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:49:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:50:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:50:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:50:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:50:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:50:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:50:53 (#:amount 96659736 #:time 355))
(heartbeat 2015-08-19T04:50:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:51:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:52:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:52:14 (#:amount 93000600 #:time 298))
(heartbeat 2015-08-19T04:52:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:52:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:52:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:52:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:52:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:53:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:53:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:53:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:53:38 (#:amount 96997032 #:time 350))
(heartbeat 2015-08-19T04:53:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:53:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:53:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:54:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:55:01 (#:amount 93255240 #:time 349))
(heartbeat 2015-08-19T04:55:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:55:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:55:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:55:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:55:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:55:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:56:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:56:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:56:24 (#:amount 96380880 #:time 353))
(heartbeat 2015-08-19T04:56:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:56:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:56:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:56:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:57:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:57:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:57:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:57:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:57:47 (#:amount 93380976 #:time 348))
(heartbeat 2015-08-19T04:57:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:57:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:58:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:59:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T04:59:12 (#:amount 96111976 #:time 305))
(heartbeat 2015-08-19T04:59:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:59:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:59:39 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T04:59:41 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (Z int) (cons -2)) -21857255) #:iterations 83007 #:time 1161506))
(new-average 2015-08-19T04:59:41 (#:model "stlc-sub-3" #:type enum #:average 1319970.4857142856 #:stderr 183026.16175384642))
(heartbeat 2015-08-19T04:59:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T04:59:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:00:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:00:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:00:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:00:33 (#:amount 92954432 #:time 335))
(heartbeat 2015-08-19T05:00:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:00:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:00:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:01:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:02:03 (#:amount 97026592 #:time 357))
(heartbeat 2015-08-19T05:02:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:02:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:02:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:02:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:02:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:02:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:03:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:03:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:03:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:03:33 (#:amount 93285224 #:time 349))
(heartbeat 2015-08-19T05:03:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:03:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:03:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:04:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:05:05 (#:amount 96545088 #:time 352))
(heartbeat 2015-08-19T05:05:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:05:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:05:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:05:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:05:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:05:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:06:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:06:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:06:29 (#:amount 93391216 #:time 301))
(heartbeat 2015-08-19T05:06:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:06:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:06:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:06:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:07:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:07:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:07:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:07:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:07:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:07:58 (#:amount 96268568 #:time 352))
(heartbeat 2015-08-19T05:07:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:08:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:08:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:08:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:08:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:08:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:09:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:09:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:09:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:09:21 (#:amount 93227112 #:time 353))
(heartbeat 2015-08-19T05:09:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:09:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:09:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:10:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:10:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:10:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:10:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:10:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:10:49 (#:amount 96397712 #:time 351))
(heartbeat 2015-08-19T05:10:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:11:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:12:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:12:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:12:17 (#:amount 93367424 #:time 295))
(heartbeat 2015-08-19T05:12:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:12:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:12:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:12:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:13:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:13:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:13:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:13:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:13:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:13:44 (#:amount 96332216 #:time 350))
(heartbeat 2015-08-19T05:13:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:14:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:15:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:15:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:15:13 (#:amount 93228600 #:time 351))
(heartbeat 2015-08-19T05:15:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:15:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:15:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:15:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:16:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:16:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:16:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:16:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:16:39 (#:amount 96284016 #:time 350))
(heartbeat 2015-08-19T05:16:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:16:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:17:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:18:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:18:07 (#:amount 93426040 #:time 351))
(heartbeat 2015-08-19T05:18:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:18:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:18:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:18:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:18:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:19:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:19:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:19:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:19:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:19:36 (#:amount 96123624 #:time 358))
(heartbeat 2015-08-19T05:19:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:19:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:20:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:21:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:21:04 (#:amount 93359112 #:time 349))
(heartbeat 2015-08-19T05:21:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:21:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:21:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:21:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:21:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:22:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:22:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:22:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:22:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:22:33 (#:amount 96240472 #:time 351))
(heartbeat 2015-08-19T05:22:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:22:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:23:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:23:55 (#:amount 93274960 #:time 345))
(heartbeat 2015-08-19T05:24:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:24:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:24:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:24:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:24:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:24:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:25:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:25:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:25:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:25:25 (#:amount 96600736 #:time 352))
(heartbeat 2015-08-19T05:25:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:25:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:25:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:26:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:26:51 (#:amount 93344920 #:time 347))
(heartbeat 2015-08-19T05:27:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:27:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:27:20 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T05:27:26 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 54) #:iterations 116044 #:time 1665430))
(new-average 2015-08-19T05:27:26 (#:model "stlc-sub-3" #:type enum #:average 1329566.5833333333 #:stderr 178128.12518570336))
(heartbeat 2015-08-19T05:27:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:27:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:27:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:28:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:28:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:28:20 (#:amount 96274144 #:time 354))
(heartbeat 2015-08-19T05:28:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:28:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:28:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:28:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:29:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:29:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:29:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:29:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:29:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:29:49 (#:amount 93158096 #:time 345))
(heartbeat 2015-08-19T05:29:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:30:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:31:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:31:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:31:16 (#:amount 96448984 #:time 352))
(heartbeat 2015-08-19T05:31:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:31:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:31:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:31:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:32:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:32:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:32:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:32:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:32:40 (#:amount 93176296 #:time 349))
(heartbeat 2015-08-19T05:32:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:32:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:33:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:34:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:34:08 (#:amount 96635672 #:time 351))
(heartbeat 2015-08-19T05:34:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:34:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:34:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:34:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:34:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:35:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:35:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:35:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:35:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:35:37 (#:amount 93144120 #:time 350))
(heartbeat 2015-08-19T05:35:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:35:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:36:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:36:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:36:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:36:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:36:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:36:47 (#:amount 96752152 #:time 300))
(counterexample 2015-08-19T05:36:48 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -55) #:iterations 40400 #:time 562453))
(new-average 2015-08-19T05:36:48 (#:model "stlc-sub-3" #:type enum #:average 1308833.7837837837 #:stderr 174483.13064367548))
(heartbeat 2015-08-19T05:36:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:37:01 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T05:37:01 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 101) #:iterations 1224 #:time 12846))
(new-average 2015-08-19T05:37:01 (#:model "stlc-sub-3" #:type enum #:average 1274728.8421052631 #:stderr 173220.0191598342))
(heartbeat 2015-08-19T05:37:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:37:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:37:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:37:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:37:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:38:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:38:10 (#:amount 92994800 #:time 348))
(heartbeat 2015-08-19T05:38:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:38:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:38:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:38:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:38:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:39:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:39:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:39:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:39:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:39:34 (#:amount 97020296 #:time 300))
(heartbeat 2015-08-19T05:39:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:39:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:40:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:40:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:40:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:40:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:40:37 (#:amount 93116472 #:time 294))
(heartbeat 2015-08-19T05:40:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:40:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:41:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:41:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:41:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:41:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:41:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:41:43 (#:amount 96700896 #:time 299))
(heartbeat 2015-08-19T05:41:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:42:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:42:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:42:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:42:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:42:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:42:47 (#:amount 93466240 #:time 346))
(heartbeat 2015-08-19T05:42:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:43:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:44:00 (#:amount 96180248 #:time 298))
(heartbeat 2015-08-19T05:44:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:44:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:44:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:44:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:44:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:44:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:45:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:45:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:45:19 (#:amount 93376304 #:time 349))
(heartbeat 2015-08-19T05:45:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:45:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:45:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:45:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:46:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:46:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:46:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:46:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:46:36 (#:amount 96252472 #:time 299))
(heartbeat 2015-08-19T05:46:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:46:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:47:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:47:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:47:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:47:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:47:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:47:46 (#:amount 93026720 #:time 299))
(heartbeat 2015-08-19T05:47:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:48:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:48:53 (#:amount 96948872 #:time 350))
(heartbeat 2015-08-19T05:49:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:49:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:49:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:49:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:49:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:49:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:50:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:50:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:50:19 (#:amount 93196880 #:time 348))
(heartbeat 2015-08-19T05:50:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:50:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:50:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:50:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:51:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:51:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:51:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:51:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:51:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:51:50 (#:amount 96575040 #:time 353))
(heartbeat 2015-08-19T05:51:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:52:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:53:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:53:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:53:19 (#:amount 93095600 #:time 352))
(heartbeat 2015-08-19T05:53:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:53:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:53:41 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T05:53:42 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 61) #:iterations 79459 #:time 1001136))
(new-average 2015-08-19T05:53:42 (#:model "stlc-sub-3" #:type enum #:average 1267713.641025641 #:stderr 168865.8081403956))
(heartbeat 2015-08-19T05:53:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:54:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:54:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:54:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:54:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:54:37 (#:amount 96685048 #:time 300))
(heartbeat 2015-08-19T05:54:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:54:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:55:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:55:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:55:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:55:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:55:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:55:49 (#:amount 93233760 #:time 348))
(heartbeat 2015-08-19T05:55:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:56:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:57:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:57:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:57:17 (#:amount 96611736 #:time 301))
(heartbeat 2015-08-19T05:57:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:57:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:57:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:57:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:58:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:58:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:58:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:58:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:58:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T05:58:45 (#:amount 93059256 #:time 354))
(heartbeat 2015-08-19T05:58:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T05:59:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:00:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:00:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:00:15 (#:amount 96646896 #:time 355))
(heartbeat 2015-08-19T06:00:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:00:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:00:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:00:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:01:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:01:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:01:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:01:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:01:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:01:44 (#:amount 93052616 #:time 349))
(heartbeat 2015-08-19T06:01:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:02:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:03:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:03:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:03:13 (#:amount 96686464 #:time 354))
(heartbeat 2015-08-19T06:03:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:03:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:03:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:03:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:04:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:04:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:04:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:04:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:04:41 (#:amount 93070424 #:time 346))
(heartbeat 2015-08-19T06:04:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:04:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:05:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:06:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:06:10 (#:amount 96817680 #:time 353))
(heartbeat 2015-08-19T06:06:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:06:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:06:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:06:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:06:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:07:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:07:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:07:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:07:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:07:39 (#:amount 93218584 #:time 349))
(heartbeat 2015-08-19T06:07:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:07:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:08:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:09:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:09:12 (#:amount 96414536 #:time 361))
(heartbeat 2015-08-19T06:09:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:09:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:09:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:09:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:09:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:10:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:10:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:10:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:10:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:10:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:10:42 (#:amount 93092472 #:time 350))
(heartbeat 2015-08-19T06:10:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:11:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:12:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:12:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:12:13 (#:amount 96824000 #:time 354))
(heartbeat 2015-08-19T06:12:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:12:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:12:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:12:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:13:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:13:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:13:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:13:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:13:41 (#:amount 93402360 #:time 353))
(heartbeat 2015-08-19T06:13:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:13:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:14:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:15:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:15:11 (#:amount 96230416 #:time 355))
(heartbeat 2015-08-19T06:15:12 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T06:15:13 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (郬 (((int → (int → (list int))) → ((int → int) → (list int))) → (((list int) → (list int)) → ((list int) → (int → (list int)))))) ((λ (b int) (cons b)) -2532)) #:iterations 90183 #:time 1291827))
(new-average 2015-08-19T06:15:13 (#:model "stlc-sub-3" #:type enum #:average 1268316.475 #:stderr 164591.13435955197))
(heartbeat 2015-08-19T06:15:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:15:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:15:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:15:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:16:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:16:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:16:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:16:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:16:39 (#:amount 92929040 #:time 349))
(heartbeat 2015-08-19T06:16:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:16:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:17:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:18:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:18:07 (#:amount 97005664 #:time 351))
(heartbeat 2015-08-19T06:18:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:18:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:18:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:18:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:18:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:19:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:19:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:19:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:19:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:19:35 (#:amount 93340000 #:time 349))
(heartbeat 2015-08-19T06:19:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:19:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:20:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:21:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:21:05 (#:amount 96536256 #:time 353))
(heartbeat 2015-08-19T06:21:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:21:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:21:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:21:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:21:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:22:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:22:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:22:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:22:25 (#:amount 93182464 #:time 345))
(heartbeat 2015-08-19T06:22:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:22:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:22:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:23:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:23:56 (#:amount 96534640 #:time 351))
(heartbeat 2015-08-19T06:24:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:24:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:24:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:24:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:24:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:24:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:25:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:25:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:25:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:25:25 (#:amount 93119512 #:time 353))
(heartbeat 2015-08-19T06:25:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:25:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:25:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:26:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:26:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:26:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:26:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:26:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:26:51 (#:amount 96605912 #:time 353))
(heartbeat 2015-08-19T06:26:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:27:52 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T06:27:56 (#:model "stlc-sub-3" #:type enum #:counterexample (λ ( ((int → (int → (int → int))) → (((list int) → (list int)) → (int → (int → int))))) ((λ (a int) (cons a)) 115)) #:iterations 53290 #:time 762301))
(new-average 2015-08-19T06:27:56 (#:model "stlc-sub-3" #:type enum #:average 1255974.6097560977 #:stderr 161000.2731422046))
(heartbeat 2015-08-19T06:28:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:28:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:28:15 (#:amount 93206088 #:time 348))
(heartbeat 2015-08-19T06:28:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:28:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:28:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:28:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:29:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:29:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:29:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:29:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:29:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:29:46 (#:amount 96609944 #:time 352))
(heartbeat 2015-08-19T06:29:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:30:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:31:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:31:09 (#:amount 93237352 #:time 347))
(heartbeat 2015-08-19T06:31:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:31:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:31:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:31:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:31:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:32:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:32:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:32:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:32:31 (#:amount 96631808 #:time 300))
(heartbeat 2015-08-19T06:32:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:32:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:32:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:33:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:33:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:33:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:33:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:33:36 (#:amount 93344192 #:time 350))
(heartbeat 2015-08-19T06:33:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:33:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:34:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:35:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:35:03 (#:amount 96558480 #:time 354))
(heartbeat 2015-08-19T06:35:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:35:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:35:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:35:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:35:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:36:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:36:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:36:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:36:26 (#:amount 93284000 #:time 348))
(heartbeat 2015-08-19T06:36:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:36:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:36:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:37:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:37:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:37:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:37:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:37:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:37:48 (#:amount 96457120 #:time 350))
(heartbeat 2015-08-19T06:37:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:38:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:39:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:39:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:39:17 (#:amount 93300712 #:time 337))
(heartbeat 2015-08-19T06:39:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:39:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:39:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:39:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:40:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:40:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:40:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:40:30 (#:amount 96122504 #:time 351))
(heartbeat 2015-08-19T06:40:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:40:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:40:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:41:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:41:58 (#:amount 93141736 #:time 347))
(heartbeat 2015-08-19T06:42:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:42:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:42:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:42:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:42:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:42:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:43:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:43:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:43:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:43:26 (#:amount 96834160 #:time 298))
(heartbeat 2015-08-19T06:43:33 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T06:43:41 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 4) #:iterations 69471 #:time 945699))
(new-average 2015-08-19T06:43:41 (#:model "stlc-sub-3" #:type enum #:average 1248587.0952380954 #:stderr 157293.75639579858))
(heartbeat 2015-08-19T06:43:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:43:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:44:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:44:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:44:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:44:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:44:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:44:51 (#:amount 93143416 #:time 348))
(heartbeat 2015-08-19T06:44:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:45:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:46:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:46:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:46:14 (#:amount 96542224 #:time 346))
(heartbeat 2015-08-19T06:46:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:46:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:46:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:46:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:47:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:47:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:47:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:47:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:47:40 (#:amount 93277176 #:time 343))
(heartbeat 2015-08-19T06:47:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:47:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:48:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:49:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:49:08 (#:amount 96367320 #:time 352))
(heartbeat 2015-08-19T06:49:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:49:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:49:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:49:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:49:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:50:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:50:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:50:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:50:27 (#:amount 93011496 #:time 300))
(heartbeat 2015-08-19T06:50:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:50:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:50:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:51:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:51:54 (#:amount 96928520 #:time 355))
(heartbeat 2015-08-19T06:52:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:52:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:52:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:52:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:52:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:52:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:53:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:53:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:53:20 (#:amount 93202248 #:time 346))
(heartbeat 2015-08-19T06:53:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:53:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:53:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:53:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:54:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:54:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:54:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:54:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:54:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:54:46 (#:amount 96459080 #:time 349))
(heartbeat 2015-08-19T06:54:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:55:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:56:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:56:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:56:14 (#:amount 93108680 #:time 350))
(heartbeat 2015-08-19T06:56:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:56:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:56:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:56:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:57:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:57:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:57:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:57:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:57:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:57:45 (#:amount 96722528 #:time 353))
(heartbeat 2015-08-19T06:57:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:58:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:59:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:59:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T06:59:15 (#:amount 93166072 #:time 348))
(heartbeat 2015-08-19T06:59:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:59:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:59:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T06:59:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:00:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:00:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:00:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:00:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:00:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:00:46 (#:amount 96583136 #:time 356))
(heartbeat 2015-08-19T07:00:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:01:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:02:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:02:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:02:17 (#:amount 93217520 #:time 350))
(heartbeat 2015-08-19T07:02:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:02:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:02:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:02:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:03:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:03:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:03:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:03:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:03:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:03:48 (#:amount 96638112 #:time 352))
(heartbeat 2015-08-19T07:03:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:04:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:05:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:05:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:05:19 (#:amount 93089296 #:time 352))
(heartbeat 2015-08-19T07:05:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:05:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:05:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:05:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:06:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:06:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:06:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:06:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:06:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:06:51 (#:amount 96664544 #:time 355))
(heartbeat 2015-08-19T07:06:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:07:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:08:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:08:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:08:20 (#:amount 93196808 #:time 350))
(heartbeat 2015-08-19T07:08:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:08:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:08:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:08:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:09:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:09:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:09:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:09:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:09:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:09:53 (#:amount 96664472 #:time 356))
(heartbeat 2015-08-19T07:09:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:10:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:11:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:11:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:11:21 (#:amount 93134152 #:time 350))
(heartbeat 2015-08-19T07:11:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:11:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:11:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:11:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:12:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:12:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:12:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:12:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:12:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:12:51 (#:amount 96799448 #:time 354))
(heartbeat 2015-08-19T07:12:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:13:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:14:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:14:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:14:19 (#:amount 92948896 #:time 348))
(heartbeat 2015-08-19T07:14:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:14:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:14:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:14:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:15:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:15:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:15:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:15:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:15:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:15:49 (#:amount 97190960 #:time 353))
(heartbeat 2015-08-19T07:15:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:16:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:17:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:17:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:17:16 (#:amount 93267440 #:time 349))
(heartbeat 2015-08-19T07:17:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:17:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:17:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:17:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:18:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:18:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:18:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:18:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:18:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:18:44 (#:amount 96493112 #:time 349))
(heartbeat 2015-08-19T07:18:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:19:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:20:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:20:12 (#:amount 93177616 #:time 351))
(heartbeat 2015-08-19T07:20:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:20:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:20:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:20:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:20:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:21:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:21:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:21:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:21:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:21:42 (#:amount 96562048 #:time 351))
(heartbeat 2015-08-19T07:21:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:21:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:22:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:23:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:23:10 (#:amount 93371392 #:time 347))
(heartbeat 2015-08-19T07:23:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:23:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:23:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:23:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:23:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:24:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:24:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:24:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:24:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:24:41 (#:amount 96436216 #:time 355))
(heartbeat 2015-08-19T07:24:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:24:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:25:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:26:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:26:07 (#:amount 93113096 #:time 349))
(heartbeat 2015-08-19T07:26:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:26:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:26:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:26:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:26:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:27:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:27:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:27:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:27:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:27:38 (#:amount 96728840 #:time 353))
(heartbeat 2015-08-19T07:27:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:27:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:28:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:29:04 (#:amount 93281696 #:time 297))
(heartbeat 2015-08-19T07:29:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:29:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:29:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:29:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:29:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:29:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:30:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:30:08 (#:amount 96651320 #:time 299))
(heartbeat 2015-08-19T07:30:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:30:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:30:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:30:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:30:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:31:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:31:13 (#:amount 93291056 #:time 298))
(heartbeat 2015-08-19T07:31:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:31:25 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T07:31:28 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -285) #:iterations 201546 #:time 2867711))
(new-average 2015-08-19T07:31:28 (#:model "stlc-sub-3" #:type enum #:average 1286241.139534884 #:stderr 158140.4234009105))
(heartbeat 2015-08-19T07:31:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:31:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:31:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:32:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:32:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:32:17 (#:amount 96340968 #:time 298))
(heartbeat 2015-08-19T07:32:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:32:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:32:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:32:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:33:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:33:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:33:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:33:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:33:35 (#:amount 93409976 #:time 352))
(heartbeat 2015-08-19T07:33:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:33:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:34:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:35:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:35:06 (#:amount 96494336 #:time 352))
(heartbeat 2015-08-19T07:35:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:35:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:35:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:35:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:35:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:36:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:36:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:36:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:36:33 (#:amount 93190984 #:time 350))
(heartbeat 2015-08-19T07:36:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:36:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:36:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:37:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:38:03 (#:amount 96719688 #:time 354))
(heartbeat 2015-08-19T07:38:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:38:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:38:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:38:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:38:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:38:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:39:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:39:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:39:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:39:31 (#:amount 93378696 #:time 349))
(heartbeat 2015-08-19T07:39:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:39:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:39:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:40:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:40:59 (#:amount 96394904 #:time 352))
(heartbeat 2015-08-19T07:41:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:41:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:41:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:41:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:41:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:41:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:42:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:42:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:42:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:42:25 (#:amount 93170256 #:time 343))
(heartbeat 2015-08-19T07:42:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:42:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:42:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:43:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:43:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:43:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:43:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:43:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:43:55 (#:amount 96676776 #:time 349))
(heartbeat 2015-08-19T07:43:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:44:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:45:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:45:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:45:23 (#:amount 93059664 #:time 349))
(heartbeat 2015-08-19T07:45:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:45:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:45:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:45:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:46:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:46:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:46:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:46:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:46:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:46:55 (#:amount 96865968 #:time 348))
(heartbeat 2015-08-19T07:46:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:47:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:48:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:48:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:48:23 (#:amount 93193984 #:time 347))
(heartbeat 2015-08-19T07:48:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:48:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:48:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:48:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:49:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:49:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:49:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:49:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:49:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:49:53 (#:amount 96592728 #:time 353))
(heartbeat 2015-08-19T07:49:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:50:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:51:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:51:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:51:20 (#:amount 93151816 #:time 345))
(heartbeat 2015-08-19T07:51:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:51:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:51:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:51:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:52:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:52:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:52:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:52:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:52:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:52:49 (#:amount 96818168 #:time 351))
(heartbeat 2015-08-19T07:52:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:53:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:54:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:54:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:54:17 (#:amount 93042288 #:time 346))
(heartbeat 2015-08-19T07:54:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:54:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:54:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:54:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:55:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:55:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:55:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:55:36 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T07:55:45 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 36) #:iterations 102266 #:time 1458039))
(new-average 2015-08-19T07:55:45 (#:model "stlc-sub-3" #:type enum #:average 1290145.6136363638 #:stderr 154553.85233544811))
(heartbeat 2015-08-19T07:55:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:55:47 (#:amount 96881680 #:time 361))
(heartbeat 2015-08-19T07:55:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:56:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:57:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:57:14 (#:amount 93338096 #:time 345))
(heartbeat 2015-08-19T07:57:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:57:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:57:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:57:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:57:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:58:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:58:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:58:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:58:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T07:58:43 (#:amount 96396496 #:time 352))
(heartbeat 2015-08-19T07:58:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:58:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T07:59:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:00:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:00:10 (#:amount 93353656 #:time 344))
(heartbeat 2015-08-19T08:00:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:00:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:00:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:00:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:00:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:01:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:01:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:01:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:01:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:01:40 (#:amount 96410336 #:time 350))
(heartbeat 2015-08-19T08:01:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:01:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:02:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:03:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:03:08 (#:amount 93265472 #:time 346))
(heartbeat 2015-08-19T08:03:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:03:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:03:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:03:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:03:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:04:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:04:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:04:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:04:34 (#:amount 96422952 #:time 351))
(heartbeat 2015-08-19T08:04:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:04:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:04:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:05:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:06:01 (#:amount 93162472 #:time 346))
(heartbeat 2015-08-19T08:06:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:06:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:06:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:06:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:06:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:06:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:07:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:07:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:07:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:07:29 (#:amount 96524056 #:time 351))
(heartbeat 2015-08-19T08:07:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:07:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:07:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:08:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:09:00 (#:amount 93332448 #:time 351))
(heartbeat 2015-08-19T08:09:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:09:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:09:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:09:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:09:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:09:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:10:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:10:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:10:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:10:27 (#:amount 96420168 #:time 350))
(heartbeat 2015-08-19T08:10:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:10:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:10:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:11:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:11:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:11:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:11:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:11:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:11:55 (#:amount 93335968 #:time 343))
(heartbeat 2015-08-19T08:11:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:12:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:13:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:13:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:13:22 (#:amount 96490600 #:time 345))
(heartbeat 2015-08-19T08:13:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:13:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:13:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:13:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:14:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:14:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:14:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:14:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:14:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:14:49 (#:amount 93316552 #:time 343))
(heartbeat 2015-08-19T08:14:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:15:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:16:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:16:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:16:19 (#:amount 96512712 #:time 351))
(heartbeat 2015-08-19T08:16:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:16:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:16:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:16:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:17:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:17:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:17:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:17:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:17:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:17:48 (#:amount 93077456 #:time 346))
(heartbeat 2015-08-19T08:17:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:18:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:19:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:19:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:19:17 (#:amount 96799144 #:time 348))
(heartbeat 2015-08-19T08:19:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:19:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:19:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:19:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:20:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:20:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:20:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:20:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:20:44 (#:amount 93378872 #:time 346))
(heartbeat 2015-08-19T08:20:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:20:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:21:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:22:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:22:11 (#:amount 96171688 #:time 350))
(heartbeat 2015-08-19T08:22:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:22:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:22:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:22:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:22:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:23:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:23:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:23:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:23:36 (#:amount 93489336 #:time 352))
(heartbeat 2015-08-19T08:23:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:23:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:23:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:24:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:25:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:25:07 (#:amount 96307288 #:time 349))
(heartbeat 2015-08-19T08:25:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:25:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:25:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:25:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:25:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:26:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:26:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:26:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:26:30 (#:amount 93031848 #:time 343))
(heartbeat 2015-08-19T08:26:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:26:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:26:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:27:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:27:58 (#:amount 96905272 #:time 350))
(heartbeat 2015-08-19T08:28:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:28:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:28:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:28:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:28:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:28:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:29:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:29:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:29:25 (#:amount 93061968 #:time 349))
(heartbeat 2015-08-19T08:29:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:29:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:29:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:29:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:30:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:30:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:30:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:30:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:30:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:30:49 (#:amount 96864760 #:time 356))
(heartbeat 2015-08-19T08:30:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:31:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:32:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:32:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:32:17 (#:amount 93223296 #:time 350))
(heartbeat 2015-08-19T08:32:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:32:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:32:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:32:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:33:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:33:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:33:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:33:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:33:45 (#:amount 96870872 #:time 350))
(heartbeat 2015-08-19T08:33:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:33:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:34:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:35:06 (#:amount 93211824 #:time 347))
(heartbeat 2015-08-19T08:35:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:35:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:35:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:35:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:35:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:35:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:36:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:36:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:36:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:36:34 (#:amount 96637992 #:time 351))
(heartbeat 2015-08-19T08:36:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:36:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:36:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:37:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:38:01 (#:amount 93328240 #:time 346))
(heartbeat 2015-08-19T08:38:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:38:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:38:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:38:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:38:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:38:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:39:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:39:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:39:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:39:30 (#:amount 96540864 #:time 354))
(heartbeat 2015-08-19T08:39:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:39:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:39:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:40:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:40:58 (#:amount 93356504 #:time 348))
(heartbeat 2015-08-19T08:41:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:41:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:41:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:41:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:41:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:41:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:42:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:42:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:42:27 (#:amount 96366072 #:time 352))
(heartbeat 2015-08-19T08:42:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:42:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:42:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:42:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:43:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:43:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:43:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:43:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:43:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:43:56 (#:amount 93142424 #:time 349))
(heartbeat 2015-08-19T08:43:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:44:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:45:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:45:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:45:25 (#:amount 96656048 #:time 353))
(heartbeat 2015-08-19T08:45:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:45:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:45:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:45:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:46:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:46:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:46:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:46:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:46:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:46:54 (#:amount 93381776 #:time 350))
(heartbeat 2015-08-19T08:46:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:47:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:48:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:48:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:48:24 (#:amount 96372088 #:time 351))
(heartbeat 2015-08-19T08:48:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:48:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:48:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:48:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:49:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:49:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:49:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:49:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:49:44 (#:amount 93365408 #:time 345))
(heartbeat 2015-08-19T08:49:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:49:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:50:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:51:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:51:14 (#:amount 96493288 #:time 350))
(heartbeat 2015-08-19T08:51:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:51:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:51:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:51:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:51:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:52:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:52:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:52:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:52:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:52:42 (#:amount 93314320 #:time 348))
(heartbeat 2015-08-19T08:52:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:52:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:53:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:54:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:54:12 (#:amount 96433416 #:time 353))
(heartbeat 2015-08-19T08:54:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:54:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:54:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:54:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:54:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:55:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:55:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:55:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:55:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:55:39 (#:amount 93143896 #:time 344))
(heartbeat 2015-08-19T08:55:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:55:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:56:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:56:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:56:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:56:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:56:48 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T08:56:52 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 22) #:iterations 255582 #:time 3668871))
(new-average 2015-08-19T08:56:52 (#:model "stlc-sub-3" #:type enum #:average 1343006.177777778 #:stderr 160060.90344650185))
(heartbeat 2015-08-19T08:56:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T08:57:05 (#:amount 96847536 #:time 354))
(heartbeat 2015-08-19T08:57:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:57:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:57:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:57:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:57:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:57:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:58:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:58:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:58:28 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T08:58:29 (#:model "stlc-sub-3" #:type enum #:counterexample (λ ( ((((int → (list int)) → (list int)) → (int → int)) → ((((list int) → (list int)) → ((list int) → (list int))) → ((int → int) → int)))) (λ (Ў (((int → (list int)) → ((list int) → int)) → (int → ((list int) → int)))) ((λ (a int) (cons a)) 5))) #:iterations 6836 #:time 97958))
(new-average 2015-08-19T08:58:29 (#:model "stlc-sub-3" #:type enum #:average 1315939.9130434783 #:stderr 158865.30303041846))
(gc-major 2015-08-19T08:58:32 (#:amount 93298960 #:time 352))
(heartbeat 2015-08-19T08:58:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:58:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:58:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T08:59:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:00:02 (#:amount 96556136 #:time 354))
(heartbeat 2015-08-19T09:00:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:00:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:00:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:00:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:00:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:00:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:01:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:01:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:01:28 (#:amount 93093616 #:time 345))
(heartbeat 2015-08-19T09:01:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:01:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:01:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:01:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:02:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:02:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:02:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:02:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:02:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:02:55 (#:amount 96993232 #:time 354))
(heartbeat 2015-08-19T09:02:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:03:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:04:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:04:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:04:22 (#:amount 93109584 #:time 349))
(heartbeat 2015-08-19T09:04:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:04:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:04:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:04:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:05:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:05:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:05:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:05:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:05:48 (#:amount 96802728 #:time 356))
(heartbeat 2015-08-19T09:05:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:05:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:06:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:07:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:07:14 (#:amount 93401168 #:time 346))
(heartbeat 2015-08-19T09:07:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:07:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:07:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:07:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:07:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:08:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:08:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:08:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:08:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:08:44 (#:amount 96351224 #:time 354))
(heartbeat 2015-08-19T09:08:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:08:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:09:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:10:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:10:10 (#:amount 93453592 #:time 349))
(heartbeat 2015-08-19T09:10:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:10:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:10:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:10:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:10:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:11:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:11:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:11:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:11:36 (#:amount 96215640 #:time 346))
(heartbeat 2015-08-19T09:11:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:11:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:11:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:12:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:13:05 (#:amount 93568448 #:time 349))
(heartbeat 2015-08-19T09:13:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:13:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:13:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:13:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:13:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:13:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:14:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:14:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:14:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:14:35 (#:amount 96267400 #:time 352))
(heartbeat 2015-08-19T09:14:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:14:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:14:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:15:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:15:59 (#:amount 93147208 #:time 346))
(heartbeat 2015-08-19T09:16:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:16:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:16:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:16:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:16:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:16:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:17:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:17:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:17:27 (#:amount 96946712 #:time 356))
(heartbeat 2015-08-19T09:17:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:17:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:17:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:17:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:18:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:18:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:18:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:18:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:18:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:18:56 (#:amount 93311432 #:time 346))
(heartbeat 2015-08-19T09:18:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:19:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:20:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:20:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:20:25 (#:amount 96711952 #:time 349))
(heartbeat 2015-08-19T09:20:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:20:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:20:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:20:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:21:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:21:19 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T09:21:20 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -29) #:iterations 95657 #:time 1370965))
(new-average 2015-08-19T09:21:20 (#:model "stlc-sub-3" #:type enum #:average 1317110.6595744682 #:stderr 155452.85412696216))
(heartbeat 2015-08-19T09:21:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:21:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:21:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:21:52 (#:amount 93319192 #:time 347))
(heartbeat 2015-08-19T09:21:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:22:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:23:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:23:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:23:20 (#:amount 96493288 #:time 353))
(heartbeat 2015-08-19T09:23:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:23:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:23:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:23:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:24:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:24:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:24:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:24:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:24:41 (#:amount 93561472 #:time 348))
(heartbeat 2015-08-19T09:24:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:24:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:25:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:26:05 (#:amount 96145488 #:time 352))
(heartbeat 2015-08-19T09:26:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:26:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:26:29 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T09:26:30 (#:model "stlc-sub-3" #:type enum #:counterexample (λ ( (((int → (list int)) → (int → (int → int))) → ((int → int) → (int → (list int))))) ((λ (a int) (cons a)) -22)) #:iterations 22349 #:time 310790))
(new-average 2015-08-19T09:26:30 (#:model "stlc-sub-3" #:type enum #:average 1296145.6458333335 #:stderr 153617.1282118049))
(heartbeat 2015-08-19T09:26:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:26:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:26:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:27:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:27:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:27:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:27:30 (#:amount 93359048 #:time 349))
(heartbeat 2015-08-19T09:27:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:27:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:27:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:28:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:29:02 (#:amount 96390784 #:time 353))
(heartbeat 2015-08-19T09:29:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:29:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:29:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:29:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:29:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:29:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:30:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:30:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:30:29 (#:amount 93482792 #:time 349))
(heartbeat 2015-08-19T09:30:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:30:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:30:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:30:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:31:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:31:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:31:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:31:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:31:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:31:59 (#:amount 96101768 #:time 357))
(heartbeat 2015-08-19T09:31:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:32:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:33:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:33:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:33:28 (#:amount 93171400 #:time 354))
(heartbeat 2015-08-19T09:33:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:33:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:33:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:33:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:34:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:35:00 (#:amount 96732256 #:time 354))
(heartbeat 2015-08-19T09:35:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:35:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:35:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:35:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:35:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:35:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:36:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:36:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:36:28 (#:amount 93310712 #:time 352))
(heartbeat 2015-08-19T09:36:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:36:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:36:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:36:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:37:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:38:01 (#:amount 96457872 #:time 358))
(heartbeat 2015-08-19T09:38:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:38:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:38:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:38:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:38:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:38:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:39:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:39:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:39:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:39:32 (#:amount 93156816 #:time 351))
(heartbeat 2015-08-19T09:39:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:39:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:39:59 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T09:40:02 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (a (((((list int) → int) → ((list int) → int)) → (((list int) → int) → int)) → (((list int) → (int → int)) → ((int → int) → ((list int) → int))))) (λ ( ((((list int) → int) → ((list int) → (list int))) → (int → ((list int) → int)))) ((λ (a int) (cons a)) -26))) #:iterations 55117 #:time 811086))
(new-average 2015-08-19T09:40:02 (#:model "stlc-sub-3" #:type enum #:average 1286246.4693877553 #:stderr 150774.7427004334))
(heartbeat 2015-08-19T09:40:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:40:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:40:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:40:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:40:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:40:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:41:03 (#:amount 96746112 #:time 352))
(heartbeat 2015-08-19T09:41:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:41:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:41:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:41:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:41:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:41:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:42:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:42:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:42:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:42:33 (#:amount 93071584 #:time 350))
(heartbeat 2015-08-19T09:42:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:42:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:43:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:44:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:44:03 (#:amount 96826328 #:time 351))
(heartbeat 2015-08-19T09:44:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:44:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:44:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:44:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:44:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:45:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:45:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:45:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:45:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:45:32 (#:amount 93358936 #:time 348))
(heartbeat 2015-08-19T09:45:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:45:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:46:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:47:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:47:03 (#:amount 96388400 #:time 354))
(heartbeat 2015-08-19T09:47:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:47:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:47:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:47:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:47:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:48:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:48:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:48:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:48:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:48:31 (#:amount 92843040 #:time 347))
(heartbeat 2015-08-19T09:48:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:48:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:49:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:50:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:50:03 (#:amount 97142936 #:time 351))
(heartbeat 2015-08-19T09:50:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:50:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:50:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:50:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:50:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:51:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:51:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:51:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:51:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:51:31 (#:amount 92973672 #:time 349))
(heartbeat 2015-08-19T09:51:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:51:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:52:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:53:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:53:02 (#:amount 97005120 #:time 354))
(heartbeat 2015-08-19T09:53:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:53:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:53:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:53:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:53:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:54:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:54:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:54:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:54:30 (#:amount 93532240 #:time 354))
(heartbeat 2015-08-19T09:54:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:54:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:54:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:55:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:56:00 (#:amount 96130240 #:time 352))
(heartbeat 2015-08-19T09:56:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:56:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:56:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:56:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:56:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:56:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:57:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:57:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:57:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:57:29 (#:amount 93229560 #:time 348))
(heartbeat 2015-08-19T09:57:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:57:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:57:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:58:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:59:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T09:59:00 (#:amount 96537616 #:time 356))
(heartbeat 2015-08-19T09:59:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:59:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:59:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:59:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T09:59:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:00:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:00:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:00:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:00:29 (#:amount 93284040 #:time 348))
(heartbeat 2015-08-19T10:00:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:00:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:00:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:01:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:02:00 (#:amount 96608320 #:time 360))
(heartbeat 2015-08-19T10:02:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:02:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:02:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:02:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:02:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:02:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:03:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:03:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:03:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:03:29 (#:amount 93550304 #:time 348))
(heartbeat 2015-08-19T10:03:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:03:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:03:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:04:50 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:04:59 (#:amount 96109400 #:time 355))
(heartbeat 2015-08-19T10:05:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:05:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:05:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:05:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:05:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:05:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:06:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:06:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:06:20 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:06:28 (#:amount 93230048 #:time 348))
(heartbeat 2015-08-19T10:06:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:06:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:06:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:07:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:07:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:07:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:07:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:07:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:07:49 (#:amount 96563192 #:time 300))
(heartbeat 2015-08-19T10:07:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:08:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:09:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:09:07 (#:amount 93217560 #:time 349))
(heartbeat 2015-08-19T10:09:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:09:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:09:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:09:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:09:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:10:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:10:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:10:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:10:22 (#:amount 96604512 #:time 298))
(heartbeat 2015-08-19T10:10:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:10:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:10:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:11:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:11:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:11:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:11:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:11:34 (#:amount 93185072 #:time 299))
(heartbeat 2015-08-19T10:11:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:11:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:12:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:12:54 (#:amount 96570768 #:time 350))
(heartbeat 2015-08-19T10:13:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:13:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:13:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:13:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:13:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:13:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:14:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:14:10 (#:amount 93171064 #:time 347))
(heartbeat 2015-08-19T10:14:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:14:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:14:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:14:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:14:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:15:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:15:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:15:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:15:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:15:31 (#:amount 96791840 #:time 349))
(heartbeat 2015-08-19T10:15:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:15:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:16:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:16:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:16:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:16:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:16:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:16:47 (#:amount 93221048 #:time 349))
(heartbeat 2015-08-19T10:16:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:17:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:17:59 (#:amount 96740856 #:time 301))
(heartbeat 2015-08-19T10:18:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:18:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:18:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:18:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:18:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:18:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:19:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:19:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:19:14 (#:amount 93086776 #:time 346))
(heartbeat 2015-08-19T10:19:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:19:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:19:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:19:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:20:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:20:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:20:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:20:30 (#:amount 96829192 #:time 301))
(heartbeat 2015-08-19T10:20:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:20:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:20:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:21:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:21:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:21:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:21:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:21:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:21:46 (#:amount 93196696 #:time 294))
(heartbeat 2015-08-19T10:21:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:22:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:23:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:23:10 (#:amount 96711240 #:time 304))
(heartbeat 2015-08-19T10:23:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:23:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:23:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:23:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:23:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:24:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:24:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:24:21 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T10:24:22 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (b int) ((λ (a int) a) b)) -5338) #:iterations 192201 #:time 2660704))
(new-average 2015-08-19T10:24:22 (#:model "stlc-sub-3" #:type enum #:average 1313735.62 #:stderr 150264.28556483172))
(heartbeat 2015-08-19T10:24:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:24:33 (#:amount 93318480 #:time 347))
(heartbeat 2015-08-19T10:24:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:24:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:25:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:25:59 (#:amount 96463264 #:time 355))
(heartbeat 2015-08-19T10:26:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:26:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:26:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:26:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:26:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:26:51 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T10:26:58 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (t int) (hd nil)) -265640) #:iterations 11336 #:time 156855))
(new-average 2015-08-19T10:26:58 (#:model "stlc-sub-3" #:type enum #:average 1291051.6862745099 #:stderr 149025.0027457256))
(heartbeat 2015-08-19T10:27:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:27:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:27:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:27:22 (#:amount 93192248 #:time 348))
(heartbeat 2015-08-19T10:27:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:27:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:27:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:28:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:28:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:28:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:28:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:28:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:28:41 (#:amount 96758680 #:time 302))
(heartbeat 2015-08-19T10:28:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:29:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:29:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:29:21 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T10:29:26 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 174) #:iterations 11079 #:time 147300))
(new-average 2015-08-19T10:29:26 (#:model "stlc-sub-3" #:type enum #:average 1269056.4423076925 #:stderr 147777.09900780706))
(heartbeat 2015-08-19T10:29:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:29:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:29:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:30:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:30:06 (#:amount 93273416 #:time 301))
(heartbeat 2015-08-19T10:30:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:30:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:30:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:30:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:30:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:31:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:31:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:31:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:31:30 (#:amount 96484184 #:time 353))
(heartbeat 2015-08-19T10:31:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:31:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:31:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:32:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:32:58 (#:amount 93339104 #:time 353))
(heartbeat 2015-08-19T10:33:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:33:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:33:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:33:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:33:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:33:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:34:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:34:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:34:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:34:28 (#:amount 96661032 #:time 354))
(heartbeat 2015-08-19T10:34:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:34:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:34:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:35:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:35:58 (#:amount 93244496 #:time 350))
(heartbeat 2015-08-19T10:36:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:36:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:36:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:36:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:36:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:36:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:37:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:37:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:37:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:37:26 (#:amount 96748280 #:time 353))
(heartbeat 2015-08-19T10:37:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:37:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:37:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:38:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:38:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:38:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:38:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:38:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:38:47 (#:amount 93544904 #:time 344))
(heartbeat 2015-08-19T10:38:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:39:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:40:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:40:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:40:15 (#:amount 96123584 #:time 351))
(heartbeat 2015-08-19T10:40:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:40:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:40:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:40:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:41:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:41:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:41:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:41:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:41:42 (#:amount 93485384 #:time 343))
(heartbeat 2015-08-19T10:41:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:41:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:42:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:43:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:43:06 (#:amount 96219632 #:time 298))
(heartbeat 2015-08-19T10:43:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:43:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:43:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:43:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:43:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:44:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:44:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:44:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:44:26 (#:amount 93705120 #:time 348))
(heartbeat 2015-08-19T10:44:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:44:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:44:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:45:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:45:55 (#:amount 96016432 #:time 350))
(heartbeat 2015-08-19T10:46:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:46:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:46:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:46:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:46:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:46:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:47:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:47:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:47:16 (#:amount 93338592 #:time 344))
(heartbeat 2015-08-19T10:47:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:47:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:47:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:47:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:48:02 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T10:48:12 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (χ ((((list int) → (list int)) → int) → ((int → int) → ((list int) → int)))) ((λ (a int) (cons a)) 68)) #:iterations 80104 #:time 1126785))
(new-average 2015-08-19T10:48:12 (#:model "stlc-sub-3" #:type enum #:average 1266372.0754716983 #:stderr 144986.89135871374))
(heartbeat 2015-08-19T10:48:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:48:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:48:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:48:38 (#:amount 96424680 #:time 353))
(heartbeat 2015-08-19T10:48:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:48:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:49:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:50:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:50:04 (#:amount 93423200 #:time 349))
(heartbeat 2015-08-19T10:50:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:50:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:50:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:50:42 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T10:50:49 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (Ĵ ((((list int) → int) → ((list int) → (list int))) → (int → int))) ((λ (a int) (cons a)) 42)) #:iterations 11187 #:time 157720))
(new-average 2015-08-19T10:50:49 (#:model "stlc-sub-3" #:type enum #:average 1245841.4814814816 #:stderr 143750.273188972))
(heartbeat 2015-08-19T10:50:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:51:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:51:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:51:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:51:31 (#:amount 96258304 #:time 354))
(heartbeat 2015-08-19T10:51:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:51:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:51:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:52:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:53:00 (#:amount 93309696 #:time 347))
(heartbeat 2015-08-19T10:53:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:53:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:53:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:53:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:53:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:53:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:54:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:54:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:54:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:54:28 (#:amount 96445688 #:time 352))
(heartbeat 2015-08-19T10:54:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:54:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:54:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:55:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:55:54 (#:amount 93424208 #:time 298))
(heartbeat 2015-08-19T10:56:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:56:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:56:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:56:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:56:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:56:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:57:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:57:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:57:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:57:22 (#:amount 96370624 #:time 354))
(heartbeat 2015-08-19T10:57:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:57:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:57:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:58:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:58:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:58:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:58:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:58:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T10:58:50 (#:amount 93297296 #:time 347))
(heartbeat 2015-08-19T10:58:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T10:59:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:00:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:00:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:00:19 (#:amount 96369536 #:time 351))
(heartbeat 2015-08-19T11:00:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:00:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:00:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:00:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:01:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:01:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:01:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:01:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:01:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:01:47 (#:amount 93383120 #:time 348))
(heartbeat 2015-08-19T11:01:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:02:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:03:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:03:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:03:15 (#:amount 96420416 #:time 353))
(heartbeat 2015-08-19T11:03:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:03:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:03:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:03:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:04:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:04:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:04:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:04:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:04:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:04:47 (#:amount 93339888 #:time 352))
(heartbeat 2015-08-19T11:04:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:05:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:06:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:06:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:06:13 (#:amount 96698544 #:time 297))
(heartbeat 2015-08-19T11:06:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:06:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:06:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:06:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:07:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:07:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:07:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:07:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:07:41 (#:amount 93168136 #:time 350))
(heartbeat 2015-08-19T11:07:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:07:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:08:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:09:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:09:06 (#:amount 96916976 #:time 352))
(heartbeat 2015-08-19T11:09:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:09:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:09:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:09:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:09:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:10:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:10:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:10:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:10:30 (#:amount 93543224 #:time 352))
(heartbeat 2015-08-19T11:10:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:10:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:10:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:11:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:11:59 (#:amount 96228216 #:time 355))
(heartbeat 2015-08-19T11:12:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:12:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:12:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:12:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:12:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:12:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:13:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:13:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:13:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:13:29 (#:amount 93308192 #:time 352))
(heartbeat 2015-08-19T11:13:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:13:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:13:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:14:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:14:59 (#:amount 96526408 #:time 359))
(heartbeat 2015-08-19T11:15:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:15:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:15:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:15:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:15:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:15:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:16:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:16:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:16:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:16:24 (#:amount 93093128 #:time 346))
(heartbeat 2015-08-19T11:16:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:16:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:16:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:17:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:17:53 (#:amount 96905416 #:time 301))
(heartbeat 2015-08-19T11:18:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:18:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:18:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:18:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:18:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:18:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:19:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:19:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:19:15 (#:amount 93184632 #:time 348))
(heartbeat 2015-08-19T11:19:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:19:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:19:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:19:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:20:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:20:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:20:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:20:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:20:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:20:46 (#:amount 96770800 #:time 351))
(heartbeat 2015-08-19T11:20:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:21:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:22:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:22:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:22:16 (#:amount 93203840 #:time 352))
(heartbeat 2015-08-19T11:22:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:22:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:22:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:22:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:23:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:23:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:23:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:23:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:23:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:23:48 (#:amount 97017464 #:time 351))
(heartbeat 2015-08-19T11:23:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:24:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:25:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:25:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:25:17 (#:amount 93127848 #:time 348))
(heartbeat 2015-08-19T11:25:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:25:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:25:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:25:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:26:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:26:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:26:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:26:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:26:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:26:50 (#:amount 96976624 #:time 353))
(heartbeat 2015-08-19T11:26:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:27:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:28:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:28:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:28:19 (#:amount 93033840 #:time 298))
(heartbeat 2015-08-19T11:28:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:28:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:28:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:28:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:29:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:29:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:29:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:29:24 (#:amount 96986120 #:time 299))
(heartbeat 2015-08-19T11:29:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:29:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:29:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:30:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:30:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:30:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:30:29 (#:amount 93472240 #:time 297))
(heartbeat 2015-08-19T11:30:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:30:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:30:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:31:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:31:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:31:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:31:34 (#:amount 96371632 #:time 304))
(heartbeat 2015-08-19T11:31:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:31:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:31:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:32:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:32:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:32:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:32:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:32:37 (#:amount 93583792 #:time 298))
(heartbeat 2015-08-19T11:32:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:32:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:33:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:33:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:33:24 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T11:33:31 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (സ (((int → (int → int)) → ((list int) → (list int))) → ((int → (int → int)) → (int → (list int))))) ((λ (a int) (cons a)) -140)) #:iterations 185164 #:time 2563368))
(new-average 2015-08-19T11:33:31 (#:model "stlc-sub-3" #:type enum #:average 1269796.5090909093 #:stderr 143131.27219115265))
(heartbeat 2015-08-19T11:33:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:33:42 (#:amount 96096672 #:time 297))
(heartbeat 2015-08-19T11:33:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:33:54 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T11:33:57 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (Ŧ (((list int) → int) → (((list int) → int) → (list int)))) ((λ (a int) (cons a)) -142)) #:iterations 2521 #:time 26411))
(new-average 2015-08-19T11:33:57 (#:model "stlc-sub-3" #:type enum #:average 1247593.1785714286 #:stderr 142295.06691918202))
(heartbeat 2015-08-19T11:34:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:34:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:34:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:34:34 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T11:34:35 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 39) #:iterations 3602 #:time 37408))
(new-average 2015-08-19T11:34:35 (#:model "stlc-sub-3" #:type enum #:average 1226361.859649123 #:stderr 141379.64079005315))
(heartbeat 2015-08-19T11:34:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:34:45 (#:amount 93495560 #:time 296))
(heartbeat 2015-08-19T11:34:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:35:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:35:56 (#:amount 96432416 #:time 352))
(heartbeat 2015-08-19T11:36:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:36:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:36:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:36:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:36:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:36:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:37:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:37:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:37:20 (#:amount 93446608 #:time 351))
(heartbeat 2015-08-19T11:37:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:37:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:37:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:37:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:38:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:38:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:38:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:38:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:38:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:38:51 (#:amount 96371712 #:time 354))
(heartbeat 2015-08-19T11:38:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:39:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:40:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:40:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:40:20 (#:amount 93424592 #:time 350))
(heartbeat 2015-08-19T11:40:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:40:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:40:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:40:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:41:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:41:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:41:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:41:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:41:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:41:50 (#:amount 96432680 #:time 349))
(heartbeat 2015-08-19T11:41:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:42:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:43:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:43:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:43:21 (#:amount 93422576 #:time 350))
(heartbeat 2015-08-19T11:43:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:43:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:43:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:43:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:44:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:44:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:44:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:44:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:44:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:44:50 (#:amount 96243880 #:time 351))
(heartbeat 2015-08-19T11:44:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:45:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:46:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:46:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:46:17 (#:amount 93539600 #:time 350))
(heartbeat 2015-08-19T11:46:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:46:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:46:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:46:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:47:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:47:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:47:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:47:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:47:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:47:48 (#:amount 96146944 #:time 352))
(heartbeat 2015-08-19T11:47:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:48:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:48:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:48:24 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T11:48:24 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (ۚ ((((list int) → int) → (list int)) → ((int → int) → ((list int) → int)))) ((λ (a int) (cons a)) -149)) #:iterations 58862 #:time 829450))
(new-average 2015-08-19T11:48:24 (#:model "stlc-sub-3" #:type enum #:average 1219518.551724138 #:stderr 139089.12725240228))
(heartbeat 2015-08-19T11:48:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:48:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:48:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:49:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:49:06 (#:amount 93276728 #:time 299))
(heartbeat 2015-08-19T11:49:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:49:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:49:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:49:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:49:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:50:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:50:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:50:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:50:27 (#:amount 96636424 #:time 355))
(heartbeat 2015-08-19T11:50:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:50:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:50:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:51:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:51:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:51:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:51:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:51:43 (#:amount 93255480 #:time 346))
(heartbeat 2015-08-19T11:51:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:51:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:52:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:53:01 (#:amount 96863072 #:time 354))
(heartbeat 2015-08-19T11:53:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:53:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:53:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:53:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:53:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:53:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:54:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:54:11 (#:amount 93367104 #:time 352))
(heartbeat 2015-08-19T11:54:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:54:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:54:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:54:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:54:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:55:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:55:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:55:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:55:33 (#:amount 96268480 #:time 299))
(heartbeat 2015-08-19T11:55:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:55:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:55:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:56:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:56:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:56:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:56:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:56:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:56:50 (#:amount 93211848 #:time 295))
(heartbeat 2015-08-19T11:56:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:57:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:58:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:58:11 (#:amount 96563744 #:time 351))
(heartbeat 2015-08-19T11:58:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:58:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:58:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:58:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:58:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:59:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:59:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:59:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T11:59:29 (#:amount 93096352 #:time 347))
(heartbeat 2015-08-19T11:59:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:59:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T11:59:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:00:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:00:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:00:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:00:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:00:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:00:48 (#:amount 96637232 #:time 348))
(heartbeat 2015-08-19T12:00:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:01:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:02:03 (#:amount 93387152 #:time 344))
(heartbeat 2015-08-19T12:02:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:02:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:02:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:02:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:02:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:02:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:03:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:03:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:03:19 (#:amount 96692376 #:time 305))
(heartbeat 2015-08-19T12:03:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:03:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:03:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:03:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:04:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:04:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:04:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:04:33 (#:amount 93515144 #:time 343))
(heartbeat 2015-08-19T12:04:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:04:45 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T12:04:49 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 27) #:iterations 77719 #:time 985466))
(new-average 2015-08-19T12:04:49 (#:model "stlc-sub-3" #:type enum #:average 1215551.559322034 #:stderr 136768.90368675746))
(heartbeat 2015-08-19T12:04:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:05:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:05:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:05:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:05:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:05:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:05:52 (#:amount 96282136 #:time 351))
(heartbeat 2015-08-19T12:05:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:06:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:07:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:07:07 (#:amount 93379504 #:time 298))
(heartbeat 2015-08-19T12:07:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:07:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:07:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:07:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:07:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:08:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:08:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:08:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:08:26 (#:amount 96549704 #:time 300))
(heartbeat 2015-08-19T12:08:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:08:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:08:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:09:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:09:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:09:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:09:35 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:09:45 (#:amount 93410816 #:time 295))
(heartbeat 2015-08-19T12:09:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:09:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:10:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:10:59 (#:amount 96314376 #:time 351))
(heartbeat 2015-08-19T12:11:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:11:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:11:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:11:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:11:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:11:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:12:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:12:11 (#:amount 93183088 #:time 348))
(heartbeat 2015-08-19T12:12:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:12:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:12:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:12:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:12:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:13:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:13:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:13:25 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:13:31 (#:amount 96865144 #:time 300))
(heartbeat 2015-08-19T12:13:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:13:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:13:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:14:55 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:14:56 (#:amount 93121696 #:time 349))
(heartbeat 2015-08-19T12:15:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:15:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:15:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:15:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:15:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:15:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:16:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:16:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:16:25 (#:amount 96833456 #:time 355))
(heartbeat 2015-08-19T12:16:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:16:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:16:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:16:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:17:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:17:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:17:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:17:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:17:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:17:51 (#:amount 93202312 #:time 355))
(heartbeat 2015-08-19T12:17:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:18:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:19:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:19:15 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:19:19 (#:amount 96852832 #:time 350))
(heartbeat 2015-08-19T12:19:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:19:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:19:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:19:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:20:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:20:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:20:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:20:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:20:45 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:20:45 (#:amount 93554984 #:time 354))
(heartbeat 2015-08-19T12:20:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:05 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:15 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:25 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:35 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:45 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:21:55 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:22:05 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:22:12 (#:amount 96136104 #:time 300))
(heartbeat 2015-08-19T12:22:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:22:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:22:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:22:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:22:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:23:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:23:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:23:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:23:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:23:36 (#:amount 93225224 #:time 348))
(heartbeat 2015-08-19T12:23:46 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T12:23:47 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 40) #:iterations 85027 #:time 1138648))
(new-average 2015-08-19T12:23:47 (#:model "stlc-sub-3" #:type enum #:average 1214269.8333333335 #:stderr 134476.21129155793))
(heartbeat 2015-08-19T12:23:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:24:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:25:00 (#:amount 96743216 #:time 326))
(heartbeat 2015-08-19T12:25:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:25:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:25:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:25:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:25:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:25:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:26:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:26:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:26:26 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:26:27 (#:amount 93550504 #:time 352))
(heartbeat 2015-08-19T12:26:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:26:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:26:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:27:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:27:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:27:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:27:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:27:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:27:52 (#:amount 96111048 #:time 350))
(heartbeat 2015-08-19T12:27:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:28:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:29:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:29:16 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:29:19 (#:amount 93116248 #:time 351))
(heartbeat 2015-08-19T12:29:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:29:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:29:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:29:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:30:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:30:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:30:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:30:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:30:46 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:30:49 (#:amount 97136120 #:time 351))
(heartbeat 2015-08-19T12:30:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:31:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:32:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:32:15 (#:amount 93091848 #:time 356))
(heartbeat 2015-08-19T12:32:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:32:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:32:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:32:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:32:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:33:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:33:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:33:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:33:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:33:42 (#:amount 96985032 #:time 355))
(heartbeat 2015-08-19T12:33:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:33:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:34:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:35:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:35:11 (#:amount 93269640 #:time 346))
(heartbeat 2015-08-19T12:35:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:35:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:35:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:35:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:35:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:36:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:36:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:36:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:36:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:36:42 (#:amount 96664384 #:time 354))
(heartbeat 2015-08-19T12:36:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:36:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:37:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:38:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:38:10 (#:amount 93295808 #:time 348))
(heartbeat 2015-08-19T12:38:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:38:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:38:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:38:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:38:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:39:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:39:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:39:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:39:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:39:40 (#:amount 96743984 #:time 352))
(heartbeat 2015-08-19T12:39:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:39:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:40:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:41:06 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:41:09 (#:amount 93503976 #:time 355))
(heartbeat 2015-08-19T12:41:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:41:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:41:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:41:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:41:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:42:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:42:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:42:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:42:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:42:38 (#:amount 96216112 #:time 352))
(heartbeat 2015-08-19T12:42:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:42:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:43:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:44:06 (#:amount 93291912 #:time 357))
(heartbeat 2015-08-19T12:44:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:44:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:44:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:44:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:44:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:44:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:45:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:45:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:45:26 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:45:36 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:45:37 (#:amount 96511744 #:time 353))
(heartbeat 2015-08-19T12:45:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:45:56 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:46:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:46:16 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:46:26 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T12:46:27 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 28) #:iterations 94757 #:time 1360798))
(new-average 2015-08-19T12:46:27 (#:model "stlc-sub-3" #:type enum #:average 1216671.9344262297 #:stderr 132275.12363338488))
(heartbeat 2015-08-19T12:46:36 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:46:46 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:46:56 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:46:58 (#:amount 93311280 #:time 348))
(heartbeat 2015-08-19T12:47:06 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:47:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:47:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:47:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:47:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:47:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:48:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:48:17 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:48:18 (#:amount 96596824 #:time 354))
(heartbeat 2015-08-19T12:48:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:48:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:48:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:48:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:49:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:49:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:49:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:49:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:49:47 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:49:47 (#:amount 93278424 #:time 348))
(heartbeat 2015-08-19T12:49:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:50:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:51:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:51:16 (#:amount 96782488 #:time 357))
(heartbeat 2015-08-19T12:51:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:51:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:51:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:51:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:51:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:52:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:52:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:52:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:52:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:52:45 (#:amount 93405264 #:time 349))
(heartbeat 2015-08-19T12:52:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:52:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:53:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:54:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:54:15 (#:amount 96404448 #:time 352))
(heartbeat 2015-08-19T12:54:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:54:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:54:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:54:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:54:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:55:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:55:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:55:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:55:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:55:44 (#:amount 93353496 #:time 349))
(heartbeat 2015-08-19T12:55:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:55:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:56:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:57:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:57:14 (#:amount 96400056 #:time 354))
(heartbeat 2015-08-19T12:57:17 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T12:57:17 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -89) #:iterations 45251 #:time 650356))
(new-average 2015-08-19T12:57:17 (#:model "stlc-sub-3" #:type enum #:average 1207537.7903225808 #:stderr 130444.35968846103))
(heartbeat 2015-08-19T12:57:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:57:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:57:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:57:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:58:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:58:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:58:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:58:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T12:58:41 (#:amount 93412616 #:time 348))
(heartbeat 2015-08-19T12:58:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:58:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T12:59:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:00:04 (#:amount 96653272 #:time 352))
(heartbeat 2015-08-19T13:00:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:00:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:00:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:00:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:00:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:00:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:01:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:01:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:01:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:01:34 (#:amount 93234960 #:time 348))
(heartbeat 2015-08-19T13:01:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:01:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:01:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:02:57 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:03:06 (#:amount 96669024 #:time 349))
(heartbeat 2015-08-19T13:03:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:03:17 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T13:03:18 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 43) #:iterations 25000 #:time 360782))
(new-average 2015-08-19T13:03:18 (#:model "stlc-sub-3" #:type enum #:average 1194097.2222222225 #:stderr 129058.89318328096))
(heartbeat 2015-08-19T13:03:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:03:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:03:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:03:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:04:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:04:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:04:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:04:36 (#:amount 93084336 #:time 348))
(heartbeat 2015-08-19T13:04:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:04:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:04:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:05:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:06:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:06:08 (#:amount 96952608 #:time 352))
(heartbeat 2015-08-19T13:06:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:06:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:06:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:06:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:06:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:07:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:07:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:07:27 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:07:37 (#:amount 93401696 #:time 297))
(heartbeat 2015-08-19T13:07:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:07:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:07:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:08:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:08:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:08:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:08:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:08:44 (#:amount 96249064 #:time 351))
(heartbeat 2015-08-19T13:08:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:08:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:09:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:10:07 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:10:13 (#:amount 93245016 #:time 348))
(heartbeat 2015-08-19T13:10:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:10:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:10:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:10:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:10:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:11:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:11:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:11:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:11:37 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:11:43 (#:amount 96844392 #:time 350))
(heartbeat 2015-08-19T13:11:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:11:57 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:07 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:17 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:27 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:37 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:47 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:12:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:13:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:13:11 (#:amount 93473960 #:time 349))
(heartbeat 2015-08-19T13:13:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:13:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:13:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:13:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:13:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:14:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:14:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:14:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:14:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:14:41 (#:amount 96410136 #:time 349))
(heartbeat 2015-08-19T13:14:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:14:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:15:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:16:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:16:09 (#:amount 93195880 #:time 349))
(heartbeat 2015-08-19T13:16:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:16:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:16:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:16:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:16:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:17:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:17:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:17:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:17:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:17:40 (#:amount 96780552 #:time 351))
(heartbeat 2015-08-19T13:17:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:17:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:18:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:19:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:19:09 (#:amount 93308544 #:time 347))
(heartbeat 2015-08-19T13:19:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:19:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:19:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:19:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:19:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:20:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:20:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:20:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:20:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:20:39 (#:amount 96522848 #:time 354))
(heartbeat 2015-08-19T13:20:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:20:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:21:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:22:04 (#:amount 93141648 #:time 297))
(heartbeat 2015-08-19T13:22:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:22:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:22:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:22:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:22:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:22:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:23:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:23:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:23:26 (#:amount 96871968 #:time 352))
(heartbeat 2015-08-19T13:23:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:23:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:23:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:23:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:24:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:24:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:24:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:24:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:24:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:24:51 (#:amount 93361184 #:time 296))
(heartbeat 2015-08-19T13:24:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:25:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:26:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:26:10 (#:amount 96590368 #:time 295))
(heartbeat 2015-08-19T13:26:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:26:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:26:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:26:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:26:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:27:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:27:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:27:26 (#:amount 93505856 #:time 347))
(heartbeat 2015-08-19T13:27:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:27:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:27:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:27:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:28:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:28:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:28:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:28:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:28:48 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:28:51 (#:amount 96365664 #:time 351))
(heartbeat 2015-08-19T13:28:58 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T13:29:00 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (Ο ((((list int) → int) → (int → (list int))) → ((int → (list int)) → int))) ((λ (a int) (cons a)) -16)) #:iterations 109740 #:time 1542277))
(new-average 2015-08-19T13:29:00 (#:model "stlc-sub-3" #:type enum #:average 1199537.5312500002 #:stderr 127142.78857777707))
(heartbeat 2015-08-19T13:29:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:29:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:29:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:29:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:29:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:29:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:30:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:30:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:30:19 (#:amount 93132816 #:time 294))
(heartbeat 2015-08-19T13:30:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:30:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:30:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:30:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:31:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:31:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:31:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:31:31 (#:amount 96680200 #:time 298))
(heartbeat 2015-08-19T13:31:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:31:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:31:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:32:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:32:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:32:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:32:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:32:39 (#:amount 93523432 #:time 349))
(heartbeat 2015-08-19T13:32:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:32:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:33:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:34:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:34:10 (#:amount 96229240 #:time 354))
(heartbeat 2015-08-19T13:34:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:34:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:34:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:34:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:34:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:35:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:35:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:35:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:35:32 (#:amount 93488512 #:time 352))
(heartbeat 2015-08-19T13:35:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:35:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:35:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:36:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:37:04 (#:amount 96262032 #:time 352))
(heartbeat 2015-08-19T13:37:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:37:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:37:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:37:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:37:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:37:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:38:08 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T13:38:10 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (b int) ((λ (a int) a) b)) 8) #:iterations 40684 #:time 549957))
(new-average 2015-08-19T13:38:10 (#:model "stlc-sub-3" #:type enum #:average 1189543.9846153848 #:stderr 125569.76612067))
(heartbeat 2015-08-19T13:38:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:38:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:38:31 (#:amount 93336616 #:time 349))
(heartbeat 2015-08-19T13:38:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:38:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:38:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:39:58 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:40:00 (#:amount 96401296 #:time 352))
(counterexample 2015-08-19T13:40:07 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 62) #:iterations 8050 #:time 117129))
(new-average 2015-08-19T13:40:07 (#:model "stlc-sub-3" #:type enum #:average 1173295.272727273 #:stderr 124715.57924235435))
(heartbeat 2015-08-19T13:40:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:40:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:40:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:40:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:40:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:40:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:41:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:41:18 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:41:21 (#:amount 93348576 #:time 344))
(heartbeat 2015-08-19T13:41:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:41:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:41:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:41:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:42:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:42:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:42:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:42:38 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:42:46 (#:amount 96662264 #:time 303))
(heartbeat 2015-08-19T13:42:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:42:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:43:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:44:08 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:44:10 (#:amount 93483208 #:time 351))
(heartbeat 2015-08-19T13:44:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:44:28 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:44:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:44:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:44:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:45:08 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:45:18 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:45:28 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:45:35 (#:amount 96577536 #:time 355))
(heartbeat 2015-08-19T13:45:38 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:45:48 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:45:58 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:46:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:46:19 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T13:46:26 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) -18) #:iterations 27704 #:time 378806))
(new-average 2015-08-19T13:46:26 (#:model "stlc-sub-3" #:type enum #:average 1161437.2238805972 #:stderr 123411.06614054002))
(heartbeat 2015-08-19T13:46:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:46:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:46:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:46:57 (#:amount 93236760 #:time 344))
(heartbeat 2015-08-19T13:46:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:47:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:48:09 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:48:16 (#:amount 96714888 #:time 351))
(heartbeat 2015-08-19T13:48:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:48:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:48:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:48:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:48:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:49:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:49:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:49:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:49:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:49:39 (#:amount 93534976 #:time 350))
(heartbeat 2015-08-19T13:49:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:49:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:50:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:51:04 (#:amount 96114768 #:time 354))
(heartbeat 2015-08-19T13:51:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:51:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:51:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:51:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:51:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:51:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:52:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:52:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:52:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:52:34 (#:amount 93400632 #:time 349))
(heartbeat 2015-08-19T13:52:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:52:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:52:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:53:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:53:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:53:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:53:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:53:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:53:58 (#:amount 96306768 #:time 351))
(heartbeat 2015-08-19T13:53:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:54:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:55:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:55:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:55:26 (#:amount 93208024 #:time 351))
(heartbeat 2015-08-19T13:55:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:55:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:55:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:55:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:56:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:56:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:56:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:56:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:56:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:56:56 (#:amount 96857072 #:time 356))
(heartbeat 2015-08-19T13:56:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:57:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:58:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:58:19 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:58:25 (#:amount 93511968 #:time 353))
(heartbeat 2015-08-19T13:58:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:58:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:58:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:58:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:59:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:59:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:59:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:59:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T13:59:49 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T13:59:52 (#:amount 96186960 #:time 297))
(heartbeat 2015-08-19T13:59:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:00:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:01:09 (#:amount 93382512 #:time 347))
(heartbeat 2015-08-19T14:01:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:01:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:01:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:01:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:01:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:01:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:02:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:02:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:02:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:02:39 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:02:40 (#:amount 96658752 #:time 358))
(heartbeat 2015-08-19T14:02:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:02:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:03:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:04:08 (#:amount 93344976 #:time 349))
(heartbeat 2015-08-19T14:04:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:04:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:04:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:04:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:04:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:04:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:05:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:05:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:05:29 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:05:39 (#:amount 96438200 #:time 353))
(heartbeat 2015-08-19T14:05:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:05:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:05:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:06:59 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:07:08 (#:amount 92991376 #:time 349))
(heartbeat 2015-08-19T14:07:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:07:19 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T14:07:29 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) ((λ (a int) a) a)) -509) #:iterations 88813 #:time 1263183))
(new-average 2015-08-19T14:07:29 (#:model "stlc-sub-3" #:type enum #:average 1162933.4852941178 #:stderr 121591.8595204241))
(heartbeat 2015-08-19T14:07:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:07:39 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:07:49 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:07:59 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:08:09 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:08:19 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:08:29 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:08:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:08:40 (#:amount 97259568 #:time 354))
(heartbeat 2015-08-19T14:08:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:09:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:10:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:10:09 (#:amount 93234760 #:time 349))
(heartbeat 2015-08-19T14:10:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:10:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:10:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:10:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:10:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:11:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:11:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:11:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:11:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:11:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:11:40 (#:amount 96737448 #:time 356))
(heartbeat 2015-08-19T14:11:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:12:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:13:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:13:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:13:11 (#:amount 93307520 #:time 350))
(heartbeat 2015-08-19T14:13:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:13:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:13:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:13:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:14:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:14:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:14:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:14:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:14:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:14:45 (#:amount 96762000 #:time 355))
(heartbeat 2015-08-19T14:14:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:15:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:16:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:16:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:16:14 (#:amount 93326832 #:time 351))
(heartbeat 2015-08-19T14:16:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:16:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:16:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:16:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:17:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:17:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:17:20 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T14:17:24 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (a int) (cons a)) 648) #:iterations 39936 #:time 595704))
(new-average 2015-08-19T14:17:24 (#:model "stlc-sub-3" #:type enum #:average 1154712.7681159421 #:stderr 120098.3843900093))
(heartbeat 2015-08-19T14:17:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:17:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:17:46 (#:amount 96505896 #:time 354))
(heartbeat 2015-08-19T14:17:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:18:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:19:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:19:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:19:15 (#:amount 93252880 #:time 349))
(heartbeat 2015-08-19T14:19:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:19:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:19:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:19:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:20:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:20:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:20:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:20:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:20:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:20:47 (#:amount 96739280 #:time 353))
(heartbeat 2015-08-19T14:20:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:21:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:22:00 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T14:22:04 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (b int) (cons b)) 2069) #:iterations 18833 #:time 279212))
(new-average 2015-08-19T14:22:04 (#:model "stlc-sub-3" #:type enum #:average 1142205.6142857145 #:stderr 119029.18695101984))
(heartbeat 2015-08-19T14:22:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:22:16 (#:amount 93278368 #:time 350))
(heartbeat 2015-08-19T14:22:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:22:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:22:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:22:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:23:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:23:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:23:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:23:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:23:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:23:46 (#:amount 96414344 #:time 354))
(heartbeat 2015-08-19T14:23:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:24:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:25:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:25:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:25:15 (#:amount 93084872 #:time 350))
(heartbeat 2015-08-19T14:25:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:25:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:25:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:25:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:26:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:26:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:26:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:26:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:26:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:26:47 (#:amount 96740064 #:time 353))
(heartbeat 2015-08-19T14:26:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:27:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:28:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:28:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:28:16 (#:amount 93268640 #:time 354))
(heartbeat 2015-08-19T14:28:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:28:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:28:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:28:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:29:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:29:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:29:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:29:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:29:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:29:47 (#:amount 96660952 #:time 356))
(heartbeat 2015-08-19T14:29:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:30:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:31:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:31:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:31:15 (#:amount 93337424 #:time 348))
(heartbeat 2015-08-19T14:31:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:31:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:31:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:31:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:32:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:32:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:32:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:32:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:32:40 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:32:45 (#:amount 96528728 #:time 355))
(heartbeat 2015-08-19T14:32:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:33:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:34:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:34:10 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:34:11 (#:amount 93277624 #:time 348))
(heartbeat 2015-08-19T14:34:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:34:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:34:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:34:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:35:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:35:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:35:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:35:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:35:35 (#:amount 96661584 #:time 358))
(heartbeat 2015-08-19T14:35:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:35:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:36:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:37:00 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:37:04 (#:amount 93312648 #:time 348))
(heartbeat 2015-08-19T14:37:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:37:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:37:30 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:37:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:37:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:38:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:38:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:38:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:38:30 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:38:35 (#:amount 96517792 #:time 355))
(heartbeat 2015-08-19T14:38:40 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:38:50 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:00 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:10 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:20 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:39:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:40:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:40:04 (#:amount 93168808 #:time 350))
(heartbeat 2015-08-19T14:40:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:40:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:40:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:40:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:40:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:41:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:41:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:41:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:41:23 (#:amount 96752608 #:time 349))
(heartbeat 2015-08-19T14:41:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:41:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:41:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:42:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:42:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:42:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:42:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:42:34 (#:amount 93192936 #:time 298))
(heartbeat 2015-08-19T14:42:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:42:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:43:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:43:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:43:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:43:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:43:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:43:50 (#:amount 96784008 #:time 356))
(heartbeat 2015-08-19T14:43:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:44:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:45:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:45:07 (#:amount 93096592 #:time 349))
(heartbeat 2015-08-19T14:45:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:45:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:45:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:45:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:45:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:46:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:46:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:46:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:46:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:46:40 (#:amount 96982248 #:time 354))
(heartbeat 2015-08-19T14:46:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:46:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:47:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:48:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:48:04 (#:amount 93191448 #:time 350))
(heartbeat 2015-08-19T14:48:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:48:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:48:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:48:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:48:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:49:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:49:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:49:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:49:25 (#:amount 96709528 #:time 351))
(heartbeat 2015-08-19T14:49:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:49:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:49:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:50:51 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:50:53 (#:amount 93215240 #:time 349))
(heartbeat 2015-08-19T14:51:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:51:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:51:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:51:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:51:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:51:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:52:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:52:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:52:12 (#:amount 96616880 #:time 297))
(heartbeat 2015-08-19T14:52:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:52:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:52:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:52:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:53:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:53:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:53:21 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:53:31 (#:amount 93445576 #:time 297))
(heartbeat 2015-08-19T14:53:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:53:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:53:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:54:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:54:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:54:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:54:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:54:41 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:54:50 (#:amount 96236192 #:time 347))
(heartbeat 2015-08-19T14:54:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:55:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:56:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:56:03 (#:amount 93230208 #:time 297))
(heartbeat 2015-08-19T14:56:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:56:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:56:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:56:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:56:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:57:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:57:11 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:57:14 (#:amount 96887472 #:time 354))
(heartbeat 2015-08-19T14:57:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:57:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:57:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:57:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:58:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:58:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:58:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:58:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T14:58:39 (#:amount 93309624 #:time 297))
(heartbeat 2015-08-19T14:58:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:58:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T14:59:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:00:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:00:05 (#:amount 96641296 #:time 350))
(heartbeat 2015-08-19T15:00:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:00:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:00:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:00:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:00:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:01:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:01:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:01:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:01:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:01:34 (#:amount 93474720 #:time 346))
(heartbeat 2015-08-19T15:01:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:01:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:02:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:03:01 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:03:04 (#:amount 96293576 #:time 352))
(heartbeat 2015-08-19T15:03:11 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T15:03:14 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (߹ ((((list int) → (list int)) → int) → (int → (int → int)))) ((λ (a int) (cons a)) -56)) #:iterations 178535 #:time 2471876))
(new-average 2015-08-19T15:03:14 (#:model "stlc-sub-3" #:type enum #:average 1160933.3661971833 #:stderr 118825.83443651513))
(heartbeat 2015-08-19T15:03:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:03:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:03:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:03:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:04:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:04:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:04:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:04:31 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:04:32 (#:amount 93104432 #:time 348))
(heartbeat 2015-08-19T15:04:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:04:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:01 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:11 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:21 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:31 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:41 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:05:51 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:06:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:06:02 (#:amount 96645432 #:time 351))
(heartbeat 2015-08-19T15:06:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:06:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:06:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:06:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:06:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:07:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:07:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:07:22 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:07:27 (#:amount 93322368 #:time 351))
(heartbeat 2015-08-19T15:07:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:07:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:07:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:08:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:08:52 (#:amount 96311536 #:time 350))
(heartbeat 2015-08-19T15:09:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:09:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:09:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:09:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:09:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:09:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:10:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:10:12 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T15:10:16 (#:model "stlc-sub-3" #:type enum #:counterexample (λ (Յ (((int → int) → (int → (list int))) → ((int → int) → ((list int) → (list int))))) ((λ (a int) (cons a)) -123)) #:iterations 29437 #:time 422848))
(new-average 2015-08-19T15:10:16 (#:model "stlc-sub-3" #:type enum #:average 1150682.1805555557 #:stderr 117611.45867122312))
(gc-major 2015-08-19T15:10:21 (#:amount 93409528 #:time 348))
(heartbeat 2015-08-19T15:10:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:10:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:10:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:10:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:11:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:11:52 (#:amount 96635472 #:time 353))
(heartbeat 2015-08-19T15:12:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:12:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:12:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:12:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:12:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:12:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:13:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:13:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:13:20 (#:amount 93427880 #:time 351))
(heartbeat 2015-08-19T15:13:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:13:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:13:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:13:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:14:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:14:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:14:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:14:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:14:42 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:14:51 (#:amount 96448928 #:time 352))
(heartbeat 2015-08-19T15:14:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:15:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:16:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:16:11 (#:amount 93260536 #:time 302))
(heartbeat 2015-08-19T15:16:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:16:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:16:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:16:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:16:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:17:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:17:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:17:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:17:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:17:37 (#:amount 96740080 #:time 354))
(heartbeat 2015-08-19T15:17:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:17:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:18:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:19:02 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:19:06 (#:amount 93377728 #:time 352))
(heartbeat 2015-08-19T15:19:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:19:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:19:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:19:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:19:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:20:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:20:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:20:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:20:32 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:20:36 (#:amount 96472464 #:time 354))
(heartbeat 2015-08-19T15:20:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:20:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:21:52 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:21:58 (#:amount 93182808 #:time 295))
(heartbeat 2015-08-19T15:22:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:22:12 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:22:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:22:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:22:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:22:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:23:02 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:23:12 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:23:13 (#:amount 96809832 #:time 353))
(heartbeat 2015-08-19T15:23:22 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:23:32 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:23:42 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:23:52 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:24:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:24:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:24:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:24:30 (#:amount 93229184 #:time 344))
(heartbeat 2015-08-19T15:24:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:24:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:24:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:25:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:25:58 (#:amount 96619232 #:time 352))
(heartbeat 2015-08-19T15:26:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:26:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:26:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:26:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:26:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:26:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:27:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:27:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:27:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:27:27 (#:amount 93133080 #:time 355))
(heartbeat 2015-08-19T15:27:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:27:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:27:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:28:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:28:57 (#:amount 96981048 #:time 353))
(heartbeat 2015-08-19T15:29:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:29:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:29:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:29:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:29:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:29:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:30:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:30:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:30:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:30:26 (#:amount 93229200 #:time 352))
(heartbeat 2015-08-19T15:30:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:30:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:30:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:31:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:31:55 (#:amount 96761624 #:time 357))
(heartbeat 2015-08-19T15:32:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:32:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:32:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:32:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:32:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:32:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:33:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:33:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:33:23 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:33:25 (#:amount 93534432 #:time 348))
(heartbeat 2015-08-19T15:33:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:33:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:33:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:34:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:34:55 (#:amount 96061784 #:time 354))
(heartbeat 2015-08-19T15:35:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:35:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:35:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:35:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:35:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:35:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:36:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:36:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:36:23 (#:amount 93253112 #:time 350))
(heartbeat 2015-08-19T15:36:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:36:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:36:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:36:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:37:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:37:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:37:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:37:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:37:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:37:52 (#:amount 96636208 #:time 352))
(heartbeat 2015-08-19T15:37:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:38:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:39:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:39:13 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:39:15 (#:amount 93343752 #:time 351))
(heartbeat 2015-08-19T15:39:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:39:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:39:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:39:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:40:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:40:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:40:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:40:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:40:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:40:43 (#:amount 96496960 #:time 356))
(heartbeat 2015-08-19T15:40:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:41:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:42:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:42:12 (#:amount 93258328 #:time 349))
(heartbeat 2015-08-19T15:42:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:42:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:42:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:42:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:42:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:43:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:43:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:43:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:43:33 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:43:43 (#:amount 96741936 #:time 353))
(heartbeat 2015-08-19T15:43:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:43:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:44:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:45:03 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:45:13 (#:amount 93021832 #:time 350))
(heartbeat 2015-08-19T15:45:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:45:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:45:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:45:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:45:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:46:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:46:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:46:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:46:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:46:43 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:46:44 (#:amount 97231072 #:time 355))
(heartbeat 2015-08-19T15:46:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:47:53 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:48:03 (#:amount 93356240 #:time 347))
(heartbeat 2015-08-19T15:48:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:48:13 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:48:23 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:48:33 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:48:43 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:48:53 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:49:03 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:49:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:49:19 (#:amount 96526008 #:time 301))
(heartbeat 2015-08-19T15:49:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:49:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:49:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:49:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:50:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:50:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:50:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:50:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:50:34 (#:amount 93511840 #:time 343))
(heartbeat 2015-08-19T15:50:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:50:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:51:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:51:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:51:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:51:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:51:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:51:53 (#:amount 96530264 #:time 296))
(heartbeat 2015-08-19T15:51:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:52:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:53:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:53:06 (#:amount 92946832 #:time 346))
(heartbeat 2015-08-19T15:53:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:53:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:53:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:53:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:53:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:54:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:54:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:54:20 (#:amount 96899304 #:time 356))
(heartbeat 2015-08-19T15:54:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:54:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:54:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:54:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:55:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:55:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:55:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:55:34 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:55:35 (#:amount 93322328 #:time 345))
(heartbeat 2015-08-19T15:55:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:55:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:56:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:56:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:56:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:56:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:56:44 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:56:52 (#:amount 96663856 #:time 301))
(heartbeat 2015-08-19T15:56:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:57:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:58:04 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:58:07 (#:amount 93337680 #:time 296))
(heartbeat 2015-08-19T15:58:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:58:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:58:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:58:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:58:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:59:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:59:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:59:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T15:59:30 (#:amount 96638616 #:time 353))
(heartbeat 2015-08-19T15:59:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:59:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T15:59:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:00:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:00:59 (#:amount 93116000 #:time 353))
(heartbeat 2015-08-19T16:01:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:01:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:01:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:01:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:01:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:01:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:02:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:02:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:02:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:02:30 (#:amount 96780776 #:time 353))
(heartbeat 2015-08-19T16:02:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:02:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:02:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:03:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:03:59 (#:amount 93500512 #:time 347))
(heartbeat 2015-08-19T16:04:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:04:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:04:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:04:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:04:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:04:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:05:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:05:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:05:24 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:05:31 (#:amount 96369416 #:time 354))
(heartbeat 2015-08-19T16:05:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:05:44 (#:model "stlc-sub-3" #:type enum))
(counterexample 2015-08-19T16:05:52 (#:model "stlc-sub-3" #:type enum #:counterexample ((λ (c int) ((λ (a int) cons) c)) 12436) #:iterations 240323 #:time 3336577))
(new-average 2015-08-19T16:05:52 (#:model "stlc-sub-3" #:type enum #:average 1180625.9452054796 #:stderr 119791.95664377991))
(heartbeat 2015-08-19T16:05:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:06:54 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:06:56 (#:amount 93118592 #:time 346))
(heartbeat 2015-08-19T16:07:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:07:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:07:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:07:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:07:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:07:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:08:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:08:14 (#:model "stlc-sub-3" #:type enum))
(gc-major 2015-08-19T16:08:17 (#:amount 96901840 #:time 354))
(heartbeat 2015-08-19T16:08:24 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:08:34 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:08:44 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:08:54 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:09:04 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:09:14 (#:model "stlc-sub-3" #:type enum))
(heartbeat 2015-08-19T16:09:24 (#:model "stlc-sub-3" #:type enum))
(finished 2015-08-19T16:09:26 (#:model "stlc-sub-3" #:type enum #:time-ms 86400008 #:attempts 6221507 #:num-counterexamples 73 #:rate-terms/s 72.00817620294664 #:attempts/cexp 85226.12328767123))
| false |
d5c921bf8d772b5b779e763bf37a94d24eb51a23 | 777e810bbf2dd72d2880ff9c899ffdcbc2d9ac62 | /day3/run-test.rkt | a1159774aa180df88f7497e438a59474bf105073 | []
| no_license | disconcision/racketskool | 69c73f23be53b45db7ed364e0a0ffe74d9806fff | 54f0b2fbcbab5a9de5d41472d6fe5ccdd35d7158 | refs/heads/master | 2020-06-17T12:20:13.276456 | 2019-07-11T03:57:31 | 2019-07-11T03:57:31 | 195,922,482 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 60 | rkt | run-test.rkt | #lang s-exp "pfsh3.rkt"
(define l (run ls))
(run wc -l < l) | false |
76d3a1064cb7ddb807dc57cc18a93161b06013c1 | 82c76c05fc8ca096f2744a7423d411561b25d9bd | /typed-racket-test/fail/require-typed-struct-extra-field.rkt | 2fe1aaf30062bcb791c082a250d22bf7f6f4680e | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/typed-racket | 2cde60da289399d74e945b8f86fbda662520e1ef | f3e42b3aba6ef84b01fc25d0a9ef48cd9d16a554 | refs/heads/master | 2023-09-01T23:26:03.765739 | 2023-08-09T01:22:36 | 2023-08-09T01:22:36 | 27,412,259 | 571 | 131 | NOASSERTION | 2023-08-09T01:22:41 | 2014-12-02T03:00:29 | Racket | UTF-8 | Racket | false | false | 318 | rkt | require-typed-struct-extra-field.rkt | #;
(exn-pred ".*found 3 fields in type, but 2 fields in struct posn.*")
#lang racket/base
(module server racket
(provide (struct-out posn))
(struct posn [x y]))
(module client typed/racket
(require/typed (submod ".." server)
(#:struct posn ((x : Integer) (y : Integer) (z : Integer)))))
(require 'client)
| false |
93784c7f9fa530017213977b90c16e25b5913630 | 21d7d49a0e07472e62ae872cfee6125cbf56f338 | /0012.rkt | 5ad621d3f0c7329678c9affb5b4f165a43d9745f | []
| no_license | samdphillips/euler | 6a9cf72869f3d72cc8b08c95e25bc1442cebe7d5 | 8de2256efff98d8b7093af2d058eb62eedc98d1f | refs/heads/master | 2021-11-24T07:49:04.982593 | 2021-10-27T04:49:53 | 2021-10-27T04:49:53 | 1,365,307 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,144 | rkt | 0012.rkt | #lang racket/base
#|
The sequence of triangle numbers is generated by adding the
natural numbers. So the 7th triangle number would be
1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:
1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
Let us list the factors of the first seven triangle numbers:
1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28
We can see that 28 is the first triangle number to have over
five divisors.
What is the value of the first triangle number to have over
five hundred divisors?
|#
(require (except-in racket/set set-map)
racket/list)
(define primes (list 2))
(define (generate-primes! n [p* primes] [c (add1 (last primes))])
(cond [(zero? n)
(void)]
[(null? p*)
(set! primes (append primes (list c)))
(generate-primes! (sub1 n) primes (add1 c))]
[(zero? (modulo c (car p*)))
(generate-primes! n primes (add1 c))]
[else
(generate-primes! n (cdr p*) c)]))
(define (next-prime p)
(let ([r (member p primes)])
(if (= 1 (length r))
(begin
(generate-primes! (floor (sqrt p)))
(next-prime p))
(cadr r))))
(define (factors n)
#;(printf "(factors ~a)~%" n)
(set-union (set 1 n) (pfactors n 2 (ceiling (sqrt n)))))
;; set-map in the library returns a list...
(define (set-map st f)
(for/set ([e (in-set st)]) (f e)))
(define (pfactors n p limit)
#;(printf "(pfactors ~a ~a ~a)~%" n p limit)
(cond [(zero? (modulo n p))
(let* ([d (/ n p)]
[f* (factors d)])
(set-union (set-map f* (lambda (x) (* p x)))
f*
(set d p)))]
[(< p limit)
(pfactors n (next-prime p) limit)]
[else (set)]))
(define (triangle-number n)
(for/fold ([v 0]) ([i (in-range (add1 n))])
(+ v i)))
(define (solve [n 500])
(let/ec break
(for ([i (in-naturals 1)])
(let* ([t (triangle-number i)]
[c (set-count (factors t))])
(when (< n c)
(break i t)))))) | false |
f9957a11b6f710034a26518ce76a0b850b5f56f0 | bb14dc54eb1c44a6b17b352e7dcca5e26a195876 | /tests/interp/foreach1.rkt | 7cd7bc6a83888ae1dbde1906da152d567e8cc959 | [
"Apache-2.0"
]
| permissive | mtdol/cm | e1d96ac42377bbd833fcde4be7ff69f8a25fdd78 | 4dbec0bf18d41fda1df2488453077ec8c3f5e3cf | refs/heads/main | 2023-06-22T20:14:27.730795 | 2021-07-18T05:01:56 | 2021-07-18T05:01:56 | 341,087,770 | 0 | 0 | null | 2021-04-24T02:03:55 | 2021-02-22T05:17:00 | Racket | UTF-8 | Racket | false | false | 933 | rkt | foreach1.rkt | #lang racket
(require cm/tests/test-utils rackunit cm/core/ast)
(check-failure run "foreach x 5 7")
(check-failure run "foreach x 5 do 7")
(check-failure run "foreach x in 5 do 7")
(check-failure run "foreach float x in 5; do 7")
(check-failure run "foreach x with 5; do 7")
(check-failure run "foreach x in 5; do y")
(run-silent "def res := \"\"")
; the `let x := 1 in` will be ignored
(check-equal? (run "let x := 1 in foreach x in 1,2,\"c\"; do def res := res $ x")
(Prim0 'void))
(check-equal? (run "res")
"12c")
(run-silent "set res := \"\"")
(check-equal? (run "foreach x, y; in (1,true;), (\"bear\",3;); do def res := res $ y $ x")
(Prim0 'void))
(check-equal? (run "res")
"true13bear")
(run-silent "set res := \"\"")
(run-silent "typedef S := a,b;")
(check-equal? (run "foreach struct S (a,b;) in (struct S (5,3;)), (struct S (7,1;)); do def res := res $ b $ a")
(Prim0 'void))
(check-equal? (run "res")
"3517")
| false |
01331851c2b899cdda91fdc4d42e8fa694a7fb4e | e553691752e4d43e92c0818e2043234e7a61c01b | /test/base/quantified.rkt | 6eefbd0f29b7a4f860ec41c31baabf1c7709ac47 | [
"BSD-2-Clause"
]
| permissive | emina/rosette | 2b8c1bcf0bf744ba01ac41049a00b21d1d5d929f | 5dd348906d8bafacef6354c2e5e75a67be0bec66 | refs/heads/master | 2023-08-30T20:16:51.221490 | 2023-08-11T01:38:48 | 2023-08-11T01:38:48 | 22,478,354 | 656 | 89 | NOASSERTION | 2023-09-14T02:27:51 | 2014-07-31T17:29:18 | Racket | UTF-8 | Racket | false | false | 8,043 | rkt | quantified.rkt | #lang rosette
(require rackunit rackunit/text-ui (only-in "vc.rkt" check-exn-svm)
rosette/lib/roseunit
rosette/base/core/term rosette/base/core/bool rosette/base/core/exn rosette/base/core/result)
(define-syntax-rule (check-state actual expected)
(let ([re (with-vc expected)]
[ra (with-vc actual)])
(check-equal? (result-value ra) (result-value re))
(check-equal? (result-state ra) (result-state re))))
(define (check-pe op)
(define-symbolic a boolean?)
(define-symbolic b integer?)
(define-symbolic c real?)
(define-symbolic f (~> integer? real?))
(check-exn-svm exn:fail:svm:assert:core? #px"primitive solvable types" (thunk (op a #t))) ; not a list
(check-exn-svm exn:fail:svm:assert:core? #px"primitive solvable types" (thunk (op (list f) #t))) ; not solvable
(check-exn-svm exn:fail:svm:assert:core? #px"primitive solvable types" (thunk (op (list b 1) #t))) ; not a constant
(check-exn-svm exn:fail:svm:assert:core? #px"boolean\\?" (thunk (op (list) 1))) ; not boolean body
(check-exn-svm exn:fail:svm:assert:core? #px"boolean\\?" (thunk (op (list b c) 1))) ; not boolean body
(clear-vc!)
(check-state (op (list a b c) #t) #t) ; constant body
(check-state (op (list a b c) #f) #f) ; constant body
(check-state (op (list) a) a) ; empty list of quantified variables
(check-state (op (list b c) (= 3 (+ b c))) (expression op (list b c) (= 3 (+ b c))))
(check-state (op (list b c) (if a #t 1)) (begin (assert a) #t)) ; simplifies to #t plus type assertion
(check-state (op (list) (if a #t 1)) (begin (assert a) #t)) ; simplifies to #t plus type assertion
(check-state (op (list a b c) (= c (+ 1 (if a b 'b))))
(begin (assert a) (expression op (list a b c) (= c (+ 1 b))))) ; type assertion
(check-state (op (list a) (let () (assert a) (= b 1)))
(begin (assert a) (expression op (list a) (= b 1)))) ; explicit assertion
(check-state (op (list a b c) (when a (assert (= b 1)) (= c 3))) ; explicit and type assertion
(begin (when a (assert (= b 1))) (assert a) (expression op (list a b c) (= c 3))))
(check-state (&& a (op (list b c) (= 3 (+ b c))))
(&& a (expression op (list b c) (= 3 (+ b c)))))
(check-state (op (list b) (op (list c) (= 3 (+ b c))))
(expression op (list b)
(expression op (list c)
(= 3 (+ b c))))) )
(define (check-finitized op)
(define-symbolic a boolean?)
(define-symbolic b integer?)
(define-symbolic c real?)
(check-exn #px"cannot use \\(current-bitwidth 5\\) with a quantified formula"
(thunk (solve (assert (op (list b) (op (list c) (= 3 (+ b c))))))))
(check-exn #px"cannot use \\(current-bitwidth 5\\) with a quantified formula"
(thunk (verify (assert (&& a (op (list b) (op (list c) (= 3 (+ b c))))))))))
(define (check-sol actual expected)
(check-equal? (sat? actual) (sat? expected))
(when (sat? expected)
(check-equal? (model actual) (model expected))))
(define (check-solve)
(define-symbolic a b c d integer?)
(check-sol
(solve (assert (forall (list a c) (exists (list b) (not (= (+ a c) b))))))
(sat))
(check-sol
(solve (assert (exists (list c) (forall (list b) (not (= (+ b c) b))))))
(sat))
(check-sol
(solve (assert (exists (list a) (forall (list b) (and (= a 0) (= (+ b c) (+ a b)))))))
(sat (hash c 0)))
(check-sol
(solve (assert (exists (list a) (forall (list b) (< a (- b a))))))
(unsat))
(check-sol
(solve
(begin
(assert (forall (list a) (exists (list b) (and (= a b) (= (+ a c) b)))))
(assert (forall (list a) (exists (list b c) (and (not (= a b)) (= (+ a c) b)))))))
(sat (hash c 0)))
(check-sol
(solve
(begin
(assert (forall (list a) (exists (list b) (and (= a b) (= (+ a c) b)))))
(assert (forall (list a c) (exists (list b c) (and (not (= a b)) (= (+ a c) b)))))))
(sat (hash c 0)))
(check-sol
(solve
(begin
(assert (forall (list a) (exists (list b) (and (= a b) (= (+ a c) b)))))
(assert (forall (list a c) (exists (list b) (= (+ a c) b))))))
(sat (hash c 0)))
(check-sol
(solve
(begin
(assert (forall (list a) (exists (list b) (and (= a b) (= (+ a c) b)))))
(assert (forall (list a) (exists (list b) (and (not (= a b)) (= (+ a c) b)))))))
(unsat))
)
(define (check-eval)
(define-symbolic a b c d integer?)
(define-symbolic x y (bitvector 4))
(let ([f (forall (list a c) (exists (list b) (not (= (+ a c) b))))])
(check-equal? (evaluate f (solve (assert f))) f))
(let ([f (exists (list c) (forall (list b) (not (= (+ b c) b))))])
(check-equal? (evaluate f (solve (assert f))) f))
(let ([f (exists (list a) (forall (list b) (and (= a 0) (= (+ b c) (+ a b)))))])
(check-equal?
(evaluate f (solve (assert f)))
(exists (list a) (forall (list b) (and (= a 0) (= b (+ a b)))))))
(let* ([f (forall (list a) (exists (list b) (and (= a b) (= (+ a c) b))))]
[g (forall (list a) (exists (list b c) (and (not (= a b)) (= (+ a c) b))))]
[s (solve (begin (assert f) (assert g)))])
(check-equal?
(evaluate f s)
(forall (list a) (exists (list b) (and (= a b) (= a b)))))
(check-equal?
(evaluate g s)
g))
(let ([f (forall (list x) (bveq (bvadd x y) x))])
(check-equal?
(evaluate f (solve (assert f)))
(forall (list x) (bveq (bvadd x (bv 0 4)) x))))
)
(define (check-uninterpreted)
(let ()
(define-symbolic x y boolean?)
(define-symbolic f (~> boolean? boolean? boolean?))
(define sol (solve (assert (forall (list x y) (equal? (f x y) (or x y))))))
(check-pred (disjoin sat? unknown?) sol)
(when (sat? sol)
(check-unsat (verify (assert (equal? (evaluate (f x y) sol) (or x y)))))))
(let ()
(define-symbolic x integer?)
(define-symbolic f (~> integer? integer?))
(define sol (solve (assert (forall (list x) (= x (f x))))))
(check-pred (disjoin sat? unknown?) sol)
(when (sat? sol)
(check-unsat (verify (assert (equal? (evaluate (f x) sol) (identity x)))))))
(let ()
(define-symbolic offset integer?)
(define-symbolic a (~> integer? integer?))
(define-symbolic disk (~> integer? integer? integer?))
(define sol (solve (assert (forall (list offset) (= (a offset) (disk 5 offset))))))
(check-pred (disjoin sat? unknown?) sol)
(when (sat? sol)
(check-unsat (verify (assert (equal? (evaluate (a offset) sol) (evaluate (disk 5 offset) sol))))))
)
(let ()
(define-symbolic offset real?)
(define-symbolic a (~> real? real?))
(define-symbolic disk (~> real? real? real?))
(define sol (solve (assert (forall (list offset) (= (a offset) (disk 5.35 offset))))))
(check-pred (disjoin sat? unknown?) sol)
(when (sat? sol)
(check-unsat (verify (assert (equal? (evaluate (a offset) sol) (evaluate (disk 5.35 offset) sol))))))
)
)
(define tests:basic
(test-suite+
"Basic tests for quantified formulas"
(current-bitwidth #f)
(check-pe exists)
(check-pe forall)))
(define tests:finitized
(test-suite+
"Tests for finitization of quantified formulas"
(current-bitwidth 5)
(check-finitized exists)
(check-finitized forall)))
(define tests:solving
(test-suite+
"Tests for solving quantified formulas"
#:features '(qf_lia quantifiers)
(current-bitwidth #f)
(check-solve)))
(define tests:eval
(test-suite+
"Tests for evaluating quantified formulas"
#:features '(qf_bv qf_lia quantifiers)
(current-bitwidth #f)
(check-eval)))
(define tests:uninterpreted
(test-suite+
"Tests for solving quantified formulas in the presence of uninterpreted functions"
#:features '(qf_uf qf_lia quantifiers)
(current-bitwidth #f)
(check-uninterpreted)))
(module+ test
(time (run-tests tests:basic))
(time (run-tests tests:finitized))
(time (run-tests tests:solving))
(time (run-tests tests:eval))
(time (run-tests tests:uninterpreted)))
| true |
647a8dea41865c9904aba43fe95d171740a570fe | 22908da22a76c973bb842889b8251609f584c379 | /abnf/rfc8259/rules.rkt | 0c1724074390220d8404deab82ec4c8bb05ff6a9 | []
| no_license | tonyg/racket-abnf | 65165942c6b735c75f6136879c1f25e6076e9d4f | 1079bc5b30a227f52ac00a84dc3fcd539da5f8db | refs/heads/master | 2020-04-26T06:31:10.284802 | 2020-01-17T12:45:03 | 2020-01-17T12:45:03 | 173,366,934 | 5 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,942 | rkt | rules.rkt | #lang abnf
@require abnf/rfc5234/core-rules
@biased-choice
JSON-text = ws value ws
begin-array = ws %x5B ws ; [ left square bracket
begin-object = ws %x7B ws ; { left curly bracket
end-array = ws %x5D ws ; ] right square bracket
end-object = ws %x7D ws ; } right curly bracket
name-separator = ws %x3A ws ; : colon
value-separator = ws %x2C ws ; , comma
ws = *(
%x20 / ; Space
%x09 / ; Horizontal tab
%x0A / ; Line feed or New line
%x0D ) ; Carriage return
value = false / null / true / object / array / number / string
false = %x66.61.6c.73.65 ; false
null = %x6e.75.6c.6c ; null
true = %x74.72.75.65 ; true
object = begin-object [ member *( value-separator member ) ]
end-object
member = string name-separator value
array = begin-array [ value *( value-separator value ) ] end-array
number = [ minus ] int [ frac ] [ exp ]
decimal-point = %x2E ; .
digit1-9 = %x31-39 ; 1-9
e = %x65 / %x45 ; e E
exp = e [ minus / plus ] 1*DIGIT
frac = decimal-point 1*DIGIT
int = zero / ( digit1-9 *DIGIT )
minus = %x2D ; -
plus = %x2B ; +
zero = %x30 ; 0
string = quotation-mark *char quotation-mark
char = unescaped /
escape (
%x22 / ; " quotation mark U+0022
%x5C / ; \ reverse solidus U+005C
%x2F / ; / solidus U+002F
%x62 / ; b backspace U+0008
%x66 / ; f form feed U+000C
%x6E / ; n line feed U+000A
%x72 / ; r carriage return U+000D
%x74 / ; t tab U+0009
%x75 4HEXDIG ) ; uXXXX U+XXXX
escape = %x5C ; \
quotation-mark = %x22 ; "
unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
| false |
e470fd922fbece9966904e96889fa3eff609ff72 | c161c2096ff80424ef06d144dacdb0fc23e25635 | /character1/exercise/ex1.38.rkt | 3fb2e7ad3e120ee7649e6ad98a1d19f68e6e796b | []
| no_license | tangshipoetry/SICP | f674e4be44dfe905da4a8fc938b0f0460e061dc8 | fae33da93746c3f1fc92e4d22ccbc1153cce6ac9 | refs/heads/master | 2020-03-10T06:55:29.711600 | 2018-07-16T00:17:08 | 2018-07-16T00:17:08 | 129,242,982 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 529 | rkt | ex1.38.rkt | #lang racket
(define (aux i)
(/ (* 2 (+ i 1)) 3))
(define (d k)
(cond((= (remainder k 3) 2.0)(aux k))
(else 1.0)))
(define n(lambda(i) 1.0))
#|(define (cont-frac n d k)
(define (cf i)
(if(= k i)
(d k)
(/ (n i)
(+ (d i)
(cf (+ 1 i))))))
(cf 1))|#
(define (cont-frac n d k)
(define (iter i result)
(if(< i 1)
result
(iter (- i 1)
(/ (n i)
(+ (d i) result)))))
(iter (- k 1) (/ (n k) (d k))))
| false |
8c0e4b74ead5b0ce47e53e367ba7fa9e9cc4bc17 | 91dc09382f6cc58925f46622212d36ab37e7e4ae | /pages/blog/post-2020-10-15.rkt | 116148ae953ea862292ff02501c65af7e0b8c195 | []
| no_license | srfoster/codespells.org | 53b4e62afb2131ed7198f76d02e023e977547bdc | fe6c14a70bf3a88579bfc675403e6a4605d6473c | refs/heads/master | 2023-08-16T20:40:03.931174 | 2021-05-24T21:29:26 | 2021-05-24T21:29:26 | 285,627,595 | 3 | 1 | null | 2021-09-11T23:53:09 | 2020-08-06T17:10:42 | Racket | UTF-8 | Racket | false | false | 535 | rkt | post-2020-10-15.rkt |
#lang at-exp racket
(require "../../lang.rkt")
(require "./lang.rkt")
(define-post
2020-10-15
"Fun with Physics"
@div{
This bug took me miles off-course. Literally.
}
@div{
@p{To make my rocks mod more fun, I've been working on a physics mod.}
@p{Here, I cast a spell that simulates wind. It not only moves the rocks, but also sends me
flying for miles and miles, until I finally slam into a cliff.}
@p{Not gonna lie: It was fun!}
@(video:radial-blast.mp4)
@p{- Stephen R. Foster}
@(logo 200)
})
| false |
e7f3e2edb803f5b55424989d78d641f505e9a0f8 | bf3128c6b1cf2a164077bcef1ffa23c26c440a0b | /define-freevar/define-freevar-test.rkt | e7cb12bb4be59f626640cf2e094e16d891c73a16 | [
"MIT"
]
| permissive | bennn/syntax-parse-example | 9e961fefc50c265991665d5de7ec1047dd445ed7 | b1616936eafd97f952af050dc41cab25c50041e2 | refs/heads/master | 2022-09-21T15:43:20.335490 | 2022-09-06T00:17:37 | 2022-09-06T00:17:37 | 423,293,870 | 1 | 1 | NOASSERTION | 2021-11-01T00:38:01 | 2021-11-01T00:38:00 | null | UTF-8 | Racket | false | false | 1,762 | rkt | define-freevar-test.rkt | #lang racket/base
(module+ test
(require rackunit syntax-parse-example/define-freevar/define-freevar)
(test-case "who-error"
(define/freevar (raise-who-error message source-stx)
#:freevars (who)
(raise-syntax-error who
message
source-stx))
(check-exn #rx"knock-knock: who"
(lambda ()
(let ([who 'knock-knock])
(raise-who-error "who's there" #'door)))))
(test-case "fib-immediate"
(define/freevar (fib n)
#:freevars (init0 init1)
#:immediate
(for/fold ([a init0]
[b init1]
[fib-list '()]
#:result (reverse fib-list))
([i (in-range n)])
(values b (+ a b) (cons a fib-list))))
(define init0 2)
(check-pred
procedure?
(let ([init1 13])
fib)) ;; <- The #:immediate flag makes a difference
(check-equal?
;; init0 shadows the global definition
;;=> '(0 1 1 2 3 5 8 ...)
(let ([init0 0]
[init1 1])
(fib 10))
'(0 1 1 2 3 5 8 13 21 34))
(check-equal?
;; The free variable init1 is renamed to b
(with-freevar fib ([init1 b])
(define b 4)
(fib 10))
'(2 4 6 10 16 26 42 68 110 178))
(check-equal?
;; Another renaming example. Free variables do not have bindings.
(let ([b 5])
(with-freevar fib ([init1 b])
(fib 10)))
'(2 5 7 12 19 31 50 81 131 212))
;; Define a new open term, fib-same, with free variables renamed from fib.
(define/with-freevar fib-same fib
[init0 S]
[init1 S])
(check-equal?
(let ([S 3])
(fib-same 10))
'(3 3 6 9 15 24 39 63 102 165)))
)
| false |
e2fdbbaee631e5ebd60ad727efb07d89709dd4b8 | c161c2096ff80424ef06d144dacdb0fc23e25635 | /chapter4/exercise/ex4.56.rkt | f8f44af6f7cfacaaeeddf77428161393e135e782 | []
| no_license | tangshipoetry/SICP | f674e4be44dfe905da4a8fc938b0f0460e061dc8 | fae33da93746c3f1fc92e4d22ccbc1153cce6ac9 | refs/heads/master | 2020-03-10T06:55:29.711600 | 2018-07-16T00:17:08 | 2018-07-16T00:17:08 | 129,242,982 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 288 | rkt | ex4.56.rkt | #lang racket
(and (supervisor ?x (Ben Bitdiddle))
(address ?x ?y))
(and (salary (Ben Bitdiddle) ?x)
(salary ?person ?y)
(lisp-value > ?x ?y))
(and (job ?person ?job)
(supervisor ?person ?supervisor)
(not (job ?supervisor (computer . ?x))))
| false |
010da45c69594f48d16f4c9383998269c29774c1 | a3447654cbbafbfa344b0898caa637340e8cd6a0 | /HW13/a13.rkt | 74ebd50e47d422d7dc0c4a8f31e50bb2d1d89036 | []
| no_license | hpmsora/Racket-Program-Language-C311 | fca274de84bc7c1d53512e1ff4968a84b6028675 | 91c5a94eea0f5f1bc5933b53a1f1c45b11ac3fc2 | refs/heads/master | 2020-04-05T23:25:34.244289 | 2016-05-16T01:54:07 | 2016-05-16T01:54:07 | 58,894,136 | 3 | 6 | null | null | null | null | UTF-8 | Racket | false | false | 6,414 | rkt | a13.rkt | #lang racket
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Won Yong Ha
;;
;; CSCI-C 311
;; Assignment 13
;;
;; Start: 25 April 2016
;; End: 27 April 2016
;;
;; Comments:
;; This is too hard!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;; "fo-val" should be optional assignment!! TT
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; import
(require "mk.rkt")
(require "numbers.rkt")
;;-------------------------------------------------------------------------
;; 1. listo: helped by Nick Palumbo
;;listo
(define listo
(lambda (als)
(conde
[(== als empty)]
[(fresh (x y)
(== `(,x . ,y) als)
(listo y))]
)))
;;Testing
#|
(run 1 (q) (listo '(a b c d e)))
(run 1 (q) (listo '(a b c d . e)))
(run 4 (q) (listo q))
(run 4 (q) (listo `(a b ,q)))
|#
;;-------------------------------------------------------------------------
;; 2. facto
;;facto
(define facto
(lambda (n1 n2)
(conde
[(== n1 empty) (== n2 '(1))]
[(fresh (n1_f n2_f)
(facto n1_f n2_f)
(minuso n1 '(1) n1_f)
(*o n1 n2_f n2))]
)))
;;Testing
#|
(run 1 (q) (facto q '(0 0 0 1 1 1 1)))
(run 1 (q) (facto (build-num 5) q))
(run 6 (q) (fresh (n1 n2) (facto n1 n2) (== `(,n1 ,n2) q)))
|#
;;-------------------------------------------------------------------------
;; 3. fibs
;;fibs
(define fibs
(lambda (n)
(cond
((eqv? n 0) (values 1 1))
(else
(let ((n- (- n 1)))
(let-values (((u v) (fibs n-)))
(let ((u+v (+ u v)))
(values v u+v))))))))
;;Testing
#|
(fibs 0)
(fibs 1)
(fibs 2)
(fibs 3)
|#
;;fibso
(define fibso
(lambda (n o1 o2)
(conde
[(== n empty) (== o1 '(1))
(== o2 '(1))]
[(fresh (n_f o1_f o2_f)
(minuso n '(1) n_f)
(fibso n_f o1_f o2_f)
(pluso o1_f o2_f o2)
(== o1 o2_f)
)]
)))
;;Testing
#|
(run 1 (a b) (fibso '() a b));;'(((1) (1)))
(run 4 (q)
(fresh (n o1 o2)
(== q `(,n ,o1 ,o2))
(fibso n o1 o2)))
(run 1 (q)
(fresh (n o1)
(== q `(,n ,o1))
(fibso n o1 (build-num 5))))
(run 1 (q)
(fresh (n o2)
(== q `(,n ,o2))
(fibso n (build-num 5) o2)))
|#
;;-------------------------------------------------------------------------
;; 4.
(require (except-in (rename-in racket (eval J-eval)) ==))
;;reverseo
(define reverseo
(lambda (ls o)
(conde
[(== '() ls)
(== o '())]
[(fresh (a d)
(== `(,a . ,d) ls)
(fresh (res)
(reverseo d res)
(appendo res `(,a) o)))]
)))
(define conso
(lambda (a d p)
(== (cons a d) p)))
(define pairo
(lambda (p)
(fresh (a d)
(conso a d p))))
;; NB, there's no base case.
(define (lookup x vars vals o)
(fresh (y vars^ a vals^)
(== `(,y . ,vars^) vars)
(== `(,a . ,vals^) vals)
(conde
((== x y) (== o a))
((=/= x y) (lookup x vars^ vals^ o)))))
;;-------------------------------------------------------
;;val-ofo
;;valof*
(define (valof* exps vars vals o)
(conde
((== `() exps) (== o `()))
((fresh (exp exps^)
(== exps `(,exp . ,exps^))
(fresh (v v^)
(== o `(,v . ,v^))
(valof exp vars vals v)
(valof* exps^ vars vals v^))))))
;;valof
(define (valof exp vars vals o)
(conde
;; ((numbero exp) (== o exp))
((symbolo exp) (lookup exp vars vals o))
((== exp `(quote ,o))
(absento 'closure o)
(absento 'quote vars))
((fresh (exps)
(== exp `(list . ,exps))
(absento 'list vars)
(valof* exps vars vals o)))
((fresh (x b)
(== exp `(λ (,x) ,b))
(absento 'λ vars)
(symbolo x)
(== o `(closure ,x ,b ,vars ,vals))))
((fresh (rator rand)
(== exp `(,rator ,rand))
(fresh (x b vars^ vals^ a)
(valof rator vars vals `(closure ,x ,b ,vars^ ,vals^))
(valof rand vars vals a)
(valof b `(,x . ,vars^) `(,a . ,vals^) o))))))
;;-------------------------------------------------------
;;fo-lavo collaborate with Nick Palumbo
;;fo-lavo*
(define (fo-lavo* exps vars vals o)
(conde
((== `() exps) (== o `()))
((fresh (exp exps^)
(== exps `(,exp . ,exps^))
(fresh (v v^)
(== o `(,v . ,v^))
(fo-lavo exp vars vals v)
(fo-lavo* exps^ vars vals v^))))))
;;fo-lavo
(define (fo-lavo exp vars vals o)
(conde
((symbolo exp) (lookup exp vars vals o))
((== exp `(,o etouq))
(absento 'closure o)
(absento 'etouq vars))
((fresh (x b)
(== exp `(,b (,x) adbmal))
(absento 'adbmal vars)
(symbolo x)
(== o `(closure ,x ,b ,vars ,vals))))
((fresh (exps re)
(reverseo exp re)
(== re `(tsil . ,exps))
(absento 'tsil vars)
;;(appendo exps 'tsil exps)
(fo-lavo* exps vars vals o)))
((fresh (rator rand)
(== exp `(,rand ,rator))
(fresh (x b vars^ vals^ a)
(fo-lavo rand vars vals `(closure ,x ,b ,vars^ ,vals^))
(fo-lavo rator vars vals a)
(fo-lavo b `(,x . ,vars^) `(,a . ,vals^) o))))
))
;;Testing
#|
(run 1 (q) (fo-lavo '(etouq etouq) '() '() q))
(run 1 (q) (fo-lavo '((cat etouq) tsil) '() '() q))
(run 1 (q) (fo-lavo '((cat etouq) . tsil) '() '() q))
(run 1 (q) (fo-lavo '((dog etouq) (cat etouq) tsil) '() '() q))
(run 1 (q) (fo-lavo q '() '() q))
|#
;;-------------------------------------------------------------------------
;; 5. color-middle-earth
;;middle-earth
(define middle-earth
'((lindon eriador forodwaith)
(forodwaith lindon rhovanion eriador)
(eriador lindon forodwaith rhovanion enedwaith)
(rhovanion forodwaith eriador enedwaith rohan rhun)
(enedwaith eriador rhovanion rohan gondor)
(rohan enedwaith rhovanion rhun gondor mordor)
(gondor enedwaith rohan mordor)
(rhun rohan rhovanion khand mordor)
(mordor gondor rohan rhun khand harad)
(khand mordor rhun harad)
(harad mordor khand)))
;;color-middle-earth
;;Testing
#|
(color-middle-earth '(red orange purple black))
|#
;;-------------------------------------------------------------------------
;;Master Testing
#|
(require "a13-student-tests.rkt")
(test-file #:file-name "a13.rkt")
|# | false |
a925056dfde3d2d1424db22a67e3dca2d52a9de2 | eb6b94f2d2b82ef7940ac79e71c3a9bb4dc24d29 | /opengl/readxml.rkt | 227a0b95e4a87aec243ffa3e5f008c23ca0688d2 | [
"Apache-2.0"
]
| permissive | hendrikboom3/RacketGL | 6059752c4ac126ab5894edc118db8f5174350f6d | ea396a120e18e05168b65c743757eead6bd17302 | refs/heads/master | 2021-04-08T15:33:42.173634 | 2020-05-06T00:35:35 | 2020-05-06T00:35:35 | 248,786,811 | 1 | 0 | Apache-2.0 | 2020-03-20T15:17:20 | 2020-03-20T15:17:19 | null | UTF-8 | Racket | false | false | 32,179 | rkt | readxml.rkt | #lang racket
(require sxml)
;(require srfi/13) Don't do this. It has the wrong ersion of string-trim)
; Debugging flags
#| This program reads the xml specfile that has been downloaded from Khronos
and writes an (as yet incomplete) binding for openGL on Racket.
Whenever it encounters something not yet implemented, ot merely anomalous,
it write a comment into the output describing the problem.
These comments are a means of tracking what still has to be done.
It is also intended to be able to compare its output with the output
of the older Racket binding, possibly by diff,
and possibly by applying diff to the sorted output of the two programs.
This is another quality check.
|#
; Debugging flags
(define do-enums #t)
; whether to produce enums. value during production: #t
; Set this fo false when debugging other stuff
; to prevent being inundated with huge numbers of enums.
(define suppress-messages #f)
; whether to suppress messages entirely
; This may be useful when comparing generated code with a previous version.
(define messages-in-generated-code #t)
(define separate-trace #t) ; whether trace output goes into a separate file
; --- message conventions
#|
This program complains whenever it receives unexpected input.
This usualy arises because the program is incomplete, or was
because the author misunderstood the structure of the xml input file.
Such messages should be embedded in the output as comments.
They should always contain the word "TODO" or "LATER"
"TODO" is used for things under active development.
"LATER" is used for matters intentionally deferred for later.
to avoid diverting my attention by a plethora of currently irrelevnt messages.
-- hendrik
|#
(define output (open-output-file "/home/hendrik/dv/opengl-project/RacketGL/opengl/generated/api.inc" #:exists 'replace))
#;(define output (current-output-port))
; regular output file.
; TODO: use call-with-output-port
(define trace (if separate-trace
(open-output-file "/home/hendrik/dv/opengl-project/RacketGL/opengl/traceout" #:exists 'replace)
output)
)
(define anomaly
(if suppress-messages (open-output-nowhere)
(if messages-in-generated-code output
(current-output-port))))
; the file to which to report anomalies
; NOTE: the distinction between output and anomaly is currently not well respected
;(fprintf output "#lang racket~n") -- to be included, not required
(define export-list '())
(define (unique list message . messageargs)
; return the only element of the list, or '() if there is none.
; Produce message if not just one.
(if (equal? 1 (length list)) (car list)
(begin
(apply fprintf (cons anomaly (cons message messageargs)))
(if (null? list) list (car list))
)
)
)
(define (atmostone list message . messageargs)
; return the first element of the list, or '() if there is none.
; Produce message if there are more than one element in the list.
(if (null? list) '()
(begin
(when ( < 1 (length list))
(apply fprintf (cons anomaly (cons message messageargs)))
)
(car list)
)
)
)
; Global variables used to collect information
(define enums (make-hash))
(define type-map (make-hash)) ; TODO: what is this?
;; Here is code lifted verbatim from the original opengl42
; It would be really cool if we could do strict checking of
; the enums. And in fact the info appears to be available in enum.spec
; and I wrote the code to do it. But I quickly found out that enum.spec
; is too buggy to be useful for that purpose.
; Eveything a C compiler doesn't check is likely to be unreliable in that file...
(define strongly-typed-enums #f)
(define-struct param-spec
(name type mode shape size))
(define-struct function-spec
(name
(params #:mutable)
(return #:mutable)
(version #:mutable)
(category #:mutable)
(alias #:mutable)
(deprecated #:mutable)))
(define-struct constant-spec
(name
(value #:mutable)))
(define-struct enum-spec
(name
type
(constants #:mutable)))
(define-struct mode-dependent-type (in out))
(define type-to-vector
(make-hash
'(
(_int8 . _s8vector)
(_uint16 . _u16vector)
(_int16 . _s16vector)
(_uint32 . _u32vector)
(_int32 . _s32vector)
(_uint64 . _u64vector)
(_int64 . _s64vector)
(_float . _f32vector)
(_double* . _f64vector))))
(define vector-to-contract
(make-hash
'(
(_bytes . bytes?)
(_s8vector . s8vector?)
(_u16vector . u16vector?)
(_s16vector . s16vector?)
(_u32vector . u32vector?)
(_s32vector . s32vector?)
(_u64vector . u64vector?)
(_s64vector . s64vector?)
(_f32vector . f32vector?)
(_f64vector . f64vector?))))
(define (pointer-to type . args)
(if (and (equal? args '(1)) (not (eq? type '_void)))
(mode-dependent-type
`(_ptr i ,type) `(_ptr o ,type))
(case type
((_void) '_pointer/intptr)
((_byte _uint8) (mode-dependent-type
'_string*/utf-8
(if (null? args)
'_bytes
`(_bytes o ,@ args))))
(else
(let ((vt (hash-ref type-to-vector type #f)))
(if vt
(mode-dependent-type
`(,vt i)
(if (null? args)
vt
`(,vt o ,@ args)))
(mode-dependent-type
`(_vector i ,type)
(if (null? args)
'_pointer
`(_vector o ,type ,@ args)))))))))
#|; This is the basc type map from the old spec reader.
; It takes combinations of notations that are no longer available.
; It is kept here for reference while writing the new one.
#;(define basic-type-map
(make-hash
(list
(cons "GLshort" '_int16)
(cons "GLvoid" '_void)
(cons "const GLubyte *" (pointer-to '_uint8))
(cons "GLsync" '_GLsync)
(cons "GLhandleARB" '_uint32)
(cons "GLboolean" '_bool)
(cons "struct _cl_event *" '_pointer)
(cons "GLint64EXT" '_int64)
(cons "GLsizeiptrARB" '_intptr)
; (cons "GLDEBUGPROCARB" _GLDEBUGPROCARB)
(cons "GLenum" '_int32)
(cons "GLint" '_int32)
(cons "GLclampd" '_double*)
(cons "GLvoid*" (pointer-to '_void))
(cons "GLhalfNV"'_uint16) ; A 16-bit floating point number. You get the bits, good luck. ;-)
; (cons "_GLfuncptr" __GLfuncptr)
(cons "GLubyte" '_uint8)
; (cons "GLvdpauSurfaceNV" _GLvdpauSurfaceNV)
(cons "GLcharARB*" (pointer-to '_byte))
(cons "GLdouble*" (pointer-to '_double*))
(cons "struct _cl_context *" '_pointer)
(cons "GLcharARB" '_byte)
(cons "GLfloat" '_float)
(cons "GLuint64" '_uint64)
(cons "GLbyte" '_int8)
(cons "GLbitfield" '_uint32)
(cons "GLuint64EXT" '_uint64)
(cons "GLchar*" (pointer-to '_byte))
(cons "GLchar* const" (pointer-to '_byte))
(cons "GLsizeiptr" '_intptr)
(cons "GLchar" '_byte)
; (cons "GLUquadric*" _GLUquadric*)
(cons "GLdouble" '_double*)
(cons "GLintptr" '_intptr)
; (cons "GLUtesselator*" _GLUtesselator*)
(cons "GLsizei" '_int32)
(cons "GLvoid* const" (pointer-to '_void))
; (cons "GLDEBUGPROCAMD" _GLDEBUGPROCAMD)
(cons "GLboolean*" (pointer-to '_bool))
(cons "GLint64" '_int64)
(cons "GLintptrARB" '_intptr)
; (cons "GLUnurbs*" _GLUnurbs*)
(cons "GLuint" '_uint32)
(cons "GLclampf" '_float)
(cons "GLushort" '_uint16)
(cons "GLfloat*" (pointer-to '_float)))))
|#
;; more verbatim code
#| original version
(define (base-to-ffi-type type)
(cond
((hash-ref enums type #f)
=>
(lambda (t2) t2))
((hash-ref type-map type #f)
=>
(lambda (t2) (hash-ref basic-type-map t2 t2)))
(else type)))
|#
;; my version so far
(define (base-to-ffi-type type)
(cond
#;((hash-ref enums type #f)
=>
(lambda (t2) t2))
#;((hash-ref type-map type #f)
=>
(lambda (t2) (hash-ref basic-type-map t2 t2)))
((hash-ref basic-type-map type type) => (lambda (t2) t2))
(else type)
))
;; and more
#|
; Original version, kept for reference.
(define (cleanup-type-for-doc type)
(cond
((enum-spec? type)
(if strongly-typed-enums
(string->symbol (format "gl~a?" (enum-spec-name type)))
(cleanup-type-for-doc (base-to-ffi-type (enum-spec-type type)))))
((list? type)
(let ((head (car type)))
(case head
((_ptr) (cleanup-type-for-doc (list-ref type 2)))
((_vector) `(vectorof ,(cleanup-type-for-doc (list-ref type 2))))
(else
(hash-ref vector-to-contract head type)))))
((symbol? type)
(case type
((_void) 'void?)
((_int8) '(integer-in -128 127))
((_uint8) '(integer-in 0 255))
((_int16) '(integer-in -32768 32767))
((_uint16) '(integer-in 0 65535))
((_int32 _intptr _int64) 'exact-integer?)
((_uint32 _uint64) 'exact-nonnegative-integer?)
((_GLsync) 'GLsync?)
((_float) 'flonum?)
((_double*) 'real?)
((_bool) 'boolean?)
((_pointer) 'cpointer?)
((_pointer/intptr) 'gl-pointer?)
((_string*/utf-8) '(or/c string? bytes?))
(else
(hash-ref vector-to-contract type type))))
(else type)))
|#
;; end verbatim code
;; Operations on types
#| This program has to deal with types in three different forms:
* The original XML form, as a bunch of attributes and the like
in a param ane elsewhere
* as a Racket ctype
* as a Racket predicate
The original function 'cleanup-type-for-doc produced this from the ctype
in the original nonxml version of the binding generator
Here are the functions that do this traslation.
|#
; TODO: There are too many of these. Clean up and refactor
; This functino is from the non-XML version of this program.
; TODO: remove notations that cannot occur in the XML verison.
(define basic-type-map
(make-hash
(list
(cons "GLshort" '_int16)
(cons "GLvoid" '_void)
(cons "const GLubyte *" (pointer-to '_uint8))
(cons "GLsync" '_GLsync)
(cons "GLhandleARB" '_uint32)
(cons "GLboolean" '_bool)
(cons "struct _cl_event *" '_pointer)
(cons "GLint64EXT" '_int64)
(cons "GLsizeiptrARB" '_intptr)
; (cons "GLDEBUGPROCARB" _GLDEBUGPROCARB)
(cons "GLenum" '_int32)
(cons "GLint" '_int32)
(cons "GLclampd" '_double*)
(cons "GLvoid*" (pointer-to '_void))
(cons "GLhalfNV"'_uint16) ; A 16-bit floating point number. You get the bits, good luck. ;-)
; (cons "_GLfuncptr" __GLfuncptr)
(cons "GLubyte" '_uint8)
; (cons "GLvdpauSurfaceNV" _GLvdpauSurfaceNV)
(cons "GLcharARB*" (pointer-to '_byte))
(cons "GLdouble*" (pointer-to '_double*))
(cons "struct _cl_context *" '_pointer)
(cons "GLcharARB" '_byte)
(cons "GLfloat" '_float)
(cons "GLuint64" '_uint64)
(cons "GLbyte" '_int8)
(cons "GLbitfield" '_uint32)
(cons "GLuint64EXT" '_uint64)
(cons "GLchar*" (pointer-to '_byte))
(cons "GLchar* const" (pointer-to '_byte))
(cons "GLsizeiptr" '_intptr)
(cons "GLchar" '_byte)
; (cons "GLUquadric*" _GLUquadric*)
(cons "GLdouble" '_double*)
(cons "GLintptr" '_intptr)
; (cons "GLUtesselator*" _GLUtesselator*)
(cons "GLsizei" '_int32)
(cons "GLvoid* const" (pointer-to '_void))
; (cons "GLDEBUGPROCAMD" _GLDEBUGPROCAMD)
(cons "GLboolean*" (pointer-to '_bool))
(cons "GLint64" '_int64)
(cons "GLintptrARB" '_intptr)
; (cons "GLUnurbs*" _GLUnurbs*)
(cons "GLuint" '_uint32)
(cons "GLclampf" '_float)
(cons "GLushort" '_uint16)
(cons "GLfloat*" (pointer-to '_float)))))
(define (racket-type xmltype) ; translate the simplest type names.
(or (hash-ref basic-type-map xmltype #f) xmltype) ; this one seems to work.
)
; This function too is taken from the original nonXML version.
; It too will need to be cleaned up for the xml version.
(define (cleanup-type-for-doc type) ;TODO: ctype, not tye -- name change
(cond
; TODO: First, exceptions. These show up in this version, but not in the original.
; TODO: Find out why.
( (equal? type '())
(fprintf anomaly "; TODO: Null type ~s~n" type) '())
( (equal? type "GLenum") 'exact-integer?)
( (equal? type "GLfloat") 'flonum?)
( (equal? type "GLuint") 'exact-nonnegative-integer?)
( (equal? type '_string*/utf-8) '(or/c string? bytes?))
( (equal? type '_void) 'any) ;TODO: why oh why this?
; nonxml version says to return any when type says return void
; Am I being compatible with a bug?
; end of exceptions
((enum-spec? type)
(if strongly-typed-enums
(string->symbol (format "gl~a?" (enum-spec-name type)))
(cleanup-type-for-doc (base-to-ffi-type (enum-spec-type type)))))
((list? type) ; TODO: touble if type is '()
(let ((head (car type)))
(case head
((_ptr) (cleanup-type-for-doc (list-ref type 2)))
((_vector) `(vectorof ,(cleanup-type-for-doc (list-ref type 2))))
(else
(hash-ref vector-to-contract head type)))))
((symbol? type)
(case type
((_void) 'void?)
((_int8) '(integer-in -128 127))
((_uint8) '(integer-in 0 255))
((_int16) '(integer-in -32768 32767))
((_uint16) '(integer-in 0 65535))
((_int32 _intptr _int64) 'exact-integer?)
((_uint32 _uint64) 'exact-nonnegative-integer?)
((_GLsync) 'GLsync?)
((_float) 'flonum?)
((_double*) 'real?)
((_bool) 'boolean?)
((_pointer) 'cpointer?)
((_pointer/intptr) 'gl-pointer?)
((_string*/utf-8) '(or/c string? bytes?))
(else
(hash-ref vector-to-contract type type))))
(else type)))
(define (racket-predicate ctype) ; TODO TODO TODO TODO
(cond ; First, exceptions that cleanup-type-for-doc doesn't handle yet.
( (equal? ctype '())
(fprintf anomaly "; TODO: Null type ~s~n" ctype) '())
( (equal? ctype "GLenum") 'exact-integer?)
( (equal? ctype "GLfloat") 'flonum?)
( (equal? ctype "void ") 'any) ;TODO: why oh why this?
; nonxml version says to return any when type says return void
; Am I being compatible with a bug?
(#t (cleanup-type-for-doc ctype))
)
#;(define rtype (racket-type xmltype))
#;(cond ((eq? rtype '_int32) 'exact-integer?)
((eq? rtype '_uint32) 'exact-nonnegative-integer?)
((eq? rtype '_float) 'flonum?)
((eq? rtype '_void) 'any)
(#t rtype)
)
)
; --- processing starts here.
(define (process-comment stuff) (fprintf anomaly "; TODO: process comments.~n"))
(define (process-types stuff) (fprintf anomaly "; TODO: process types~n"))
(define (process-groups stuff) (fprintf anomaly "; TODO: process groups~n"))
(define (process-enum-header header)
(fprintf anomaly "; LAtER: enum-header ~s~n" header)
)
(define (rehexify v)
(if (and (string? v) ( >= (string-length v) 2) (equal? (substring v 0 2) "0x"))
(string-append "#x" (substring v 2))
v
))
(define (process-enum-item item)
(match item
[ (list 'enum (cons '@ xmlattributes))
;; There ought to be a way to do this with a match, but I haven't found it.
#;(match xmlattributes [(list-no-order (list 'value v) (list 'name s)(list 'alias alias) ...
;(or (list 'vendor _) (list 'comment _ ) (list 'type _ ) (list 'api _)) ...
)
'() ;; placeholder for generating enum translation
] )
(define names '())
(define values '())
(define aliases '())
(define apis '())
(for ([attr xmlattributes])
(match attr
[(list 'value v) (set! values (cons v values))]
[(list 'name n) (set! names (cons n names))]
[(list 'alias a) (set! aliases (cons a aliases))]
[(cons 'comment _) (fprintf anomaly "; LATER: write comments~n")]
[(cons 'type _)
(fprintf anomaly "; LATER: Do I need to process types in enumerations?~n")]
[(list 'api api)
(set! apis (cons (strip-white api) apis))
(fprintf anomaly "; LATER: What do I do with API? ~s from ~s apis ~s~n"
api attr apis)]
[ other (fprintf anomaly "; LATER: other enum attribute ~s~n" other)]
)
)
(unique names "; TODO: not just one name in enum ~s~n" names)
(unique values "; TODO: not just one value in enum ~s ~s~n" names values)
(define api (atmostone apis "; TODO: not just one api. ~s~n" apis))
(fprintf anomaly ";;;;;api is ~s.~n" api)
(unless (member api '("gles2"))
#| This is an opengl binding, not a gles binding
opengl and gles have different definitions for some symbols,
but Khronos lists all of them in the opengl registry.
|#
(for ([name names] [value values])
; and there should be only one of each, so only one iteration.
(fprintf output "(define ~a ~a)~n" name (rehexify value))
(fprintf output "~s~n" (list 'provide name))
(for ([a aliases])
(fprintf output "; alias for ~s~n" a)
#;(fprintf output "~a~n" (list 'provide a))
))
)
]
[(cons 'unused rest) (fprintf anomaly "; LATER: unused ~s~n" item)]
[ _ (fprintf anomaly "; unknown-enum-item ~s~n" item)]
)
)
(define (process-enum-list enum-list)
(if (pair? enum-list)
(begin
(process-enum-item (car enum-list))
(process-enum-list (cdr enum-list))
)
(cons 'enum-list-tail enum-list)
)
)
(define (process-enums enums)
(match enums [(cons header enum-list)
(process-enum-header header)
(process-enum-list enum-list)]
[ _ (fprintf "strange argument to enums. ~s~n" enums) ]
))
; Rename types
(struct prototype (ptype name group))
(define (process-proto proto)
;; I wonder why Khronos considers the param not to be part of the proto?
;; They split the identifier's type into two separate XML elements.
(define ptypes '()) ; should be only one
(define names '()) ; should be only one
(define groups '()) ; should be at most one
(for [(p proto)]
(match p
["void " (set! ptypes (cons '_void ptypes))]
; TODO: Is thre an important distinction between void here and a ptype element?
[(cons '@ attributes)
(for ([a attributes])
(match a
[(list 'group g) (set! groups (cons g groups))]
[ _
(fprintf anomaly "; TODO: What to do with attribute ~s of prototype ~s~n"
a proto)]
)
)]
[(list 'name s) (set! names (cons s names))]
[(list 'ptype s) (set! ptypes (cons s ptypes))
(fprintf anomaly "NOTE: ptype directly in proto")
] ; TODO: This seems never to occur.
[(cons glx rest) (fprintf anomaly "; LATER: what to do with glx? ~s~n" p)]
[ _ (fprintf anomaly "; TODO: unknown component ~s of prototype ~s~n" p proto)]
)
)
(define name (string->symbol (strip-white
(unique names ":TODO: too many names ~s in protoype ~s~n" names proto))))
(define ptype
(unique ptypes ":TODO: too many ptypes ~s in protoype ~s~n" ptypes proto))
#;(fprintf anomaly "process-proto sees groups ~s~n" groups)
(define group
(atmostone groups "; TODO: not just one group ~s in prototype" groups proto))
(prototype name (racket-type ptype) group) ; Do we want racket-type here?
)
(define (strip-white s) (string-trim s " " #:repeat? #t))
; example
#;(define (tuple-print tuple port mode)
(when mode (write-string "<" port))
(let ([l (tuple-ref tuple)]
[recur (case mode
[(#t) write]
[(#f) display]
[else (lambda (p port) (print p port mode))])])
(unless (zero? (vector-length l))
(recur (vector-ref l 0) port)
(for-each (lambda (e)
(write-string ", " port)
(recur e port))
(cdr (vector->list l)))))
(when mode (write-string ">" port)))
#;(struct tuple (ref)
#:methods gen:custom-write
[(define write-proc tuple-print)])
(define (parameter-print p port mode)
(fprintf port "parameter{~s ~s ~s ~s ~s}"
(parameter-type p) (parameter-name p) (parameter-len p) (parameter-const? p) (parameter-stars p)
)
)
; A parameter structure records the result of parsing an xml param entity.
; It still beeds to be translated into both the racket and the ctype notations.
(struct parameter
(type name len const? stars)
#:methods gen:custom-write [(define write-proc parameter-print)]
)
(define (primitive-ctype t2) ; TODO TODO TODO
(hash-ref basic-type-map t2 t2)
)
(define (parse-param param)
; parse a param entity and produce a struct parameter object
(define types '())
(define names '())
(define lengths '())
(define const? #f)
(define stars 0)
(for [(p param)]
(match p
[(list '@ (list 'group g))
(fprintf anomaly
"; LATER: figure out what these groups in param's are for.~n")]
[(list 'ptype t) (set! types (cons t types))]
[(list 'name n) (set! names (cons (string->symbol (strip-white n)) names))]
[(or (list '@ (list 'len len))
(list '@ (list 'len len) (list 'group _))) ; TODO: what's group?
(set! lengths (cons len lengths))
(fprintf anomaly "length ~s in param ~s~n" p param)
]
["const " (set! const? #t)
#;(fprintf anomaly "const ~s in param ~s~n" p param)] ; TODO: is this really an anomaly here?
[" *" (set! stars ( + 1 stars))
(fprintf anomaly "star ~s in param ~s~n" p param)]
[_ (fprintf anomaly "; TODO: strange param specifier ~s~n" p)]
))
(define type (unique types
"; TODO: not just one type ~s in param ~s~n" types param))
(define name (unique names
"; TODO: not just one name ~s in param ~s~n" names param))
(define len (atmostone lengths
"; TODO: not just one length ~s in param ~s~n" names param))
(parameter type name len const? stars)
#;(list name ': (racket-type type))
)
(define (param-to-contract) (void))
(define (param->ctype param) ; TODO TODO TODO Should this be parameter->ctype?
#;(fprintf trace "DEBUG: param->ctype ~s~n" param)
(match param
[ (parameter (or '_byte '_char 'char "GLchar") name (or "COMPSIZE(name)" '()) #t 1)
(list #f name ': '_string*/utf-8 )]
[ (parameter "GLuint" name "n" #t 1)
(list #f name ': '(_u32vector i))]
[ (parameter "GLboolean" name "n" #f 1)
(list #t name ': '(_vector o _bool n))] ; the #t indicates that this parameter is used for output.
[ (parameter t "residences" l c s) ; debugging catchall; should not be used
(list #f "residences" ': parameter)]
[ (parameter t name (not '()) c? (not 0)) (list #f name ': '_cptr) ]
[ (parameter type name len const? stars)
(fprintf trace "DEBUG: param->ctype ~s ~s ~s ~s ~s ~n"
type name len const? stars)
(define t (primitive-ctype type))
(fprintf trace "DEBUGt t ~s~n" t)
#| (when (equal? t "GLenum") (set! t '_int32))
(when (equal? t "GLsizei") (set! t '_int32))
(when (equal? t "GLuint") (set! t '_uint32))
(when (equal? t "GLbyte") (set! t '_uint8))
(when (equal? t "GLfloat") (set! t '_float))
|#
#;(if (and (equal? stars 1)
(or (equal? t '_byte)
(equal? t '_char) (equal? t 'char) (equal? t "GLchar") ; ><<><>
)
(equal? len "COMPSIZE(name)") const?)
#| This could be match ( (parameter (or '_byte '_char 'char "GLchar) n "COMPSIZE(name)" #t 1) |#
(set! t '_string*/utf-8)
(when (or (not (equal? stars 0)) (not (null? len)))
(set! t '_cptr)
)
)
(list #f name ': t)
]
[ _ (fprintf anomaly "Unrecognised param ~s~n" param)
param]
)
)
#;(define (param->ctype param)
(match param
[(parameter type name len const? stars)
#;(fprintf anomaly
"anomaly: unpacket parameter is type ~s name ~s len ~s const? ~s stars ~s\n"
type name len const? stars)
(when (equal? stars 1)
(cond
((and (equal? type '_byte)
(equal? len "COMPSIZE(name)") const?)
(set! type '_string*/utf-8))
((and (equal? type '_uint))
(set! type '(_u32vector i) )
)
( (not (null? len))
(set! type '_cptr)
)
)
)
(list name ': type)
]
[ _ (fprintf anomaly "TODO: What kind of parameter is ~s?~n" param) param]
)
)
(define (params->ctypes params) ; params contains parameters in ???reverse order
; Return a list of the ctypes of the parameters, also in reverse order.
#;(fprintf trace "DEBUG: params->ctypes ~s~n" params) ; <><>><
(cond
((null? params) '())
[(pair? params)
(define p (param->ctype (car params)))
(cons p (params->ctypes (cdr params)))
]
(#t (fprintf anomaly "; What is ~s doing in my parameter list?~n" params) )
))
(define (get-output-ctypes params) ; params is a list of parameters in ???reverse order each in the (#t n : t) or (n : t) form
; return a list of the output parameters, also in reerseorder.
; Output parameters are parameters which point to memory
; where the opengl function is expected to return results.
(cond
((null? params) '())
((pair? params)
(if (equal? (caar params) '#t)
(cons (cdar params) (get-output-ctypes (cdr params)))
(get-output-ctypes (cdr params))
))
(#t (fprintf anomaly "; What is ~s doing in my parameter list?~n" params) )
))
(define (process-command command)
(fprintf output "~n") ; TODO this line is temporary code
(define name '()) ; TODO: check there's only one
(define resulttype '()) ; TODO: check there's only one
(define group '())
(define proto '()) ; TODO: check there's only one
(define params '()) ; list of parameters in reverse order
(define glxtype '())
(define opcode '())
(for ([item command])
(match item
#;[(list 'proto t (list 'name n))
(set! resulttype
(if (and (string? t) (equal? "void" (strip-white t))) '_void t))
(set! name (string->symbol (strip-white n)))
]
[(cons 'proto rest)
(set! proto (process-proto rest))
(match proto
[(prototype n t g) ; formerly list n ': t)
(set! name n)
(set! resulttype
(if (and (string? t) (equal? "void" (strip-white t))) '_void t))
(set! group g) #;(fprintf anomaly "proto had group ~s\n" g)
]
[ _ (fprintf anomaly "; TODO: strange proto in command: ~s~n" command)]
)]
[(cons 'param rest) (set! params (cons (parse-param rest) params))]
[(list 'glx (list '@ (list 'type t) (list 'opcode o)))
(set! glxtype t)
(set! opcode o)
(fprintf anomaly "; LATER: whatever do i do with item ~s in command ~s~n" item name)]
[(list 'alias (list '@ (list 'name name)))
(fprintf output "; alias for ~a~n" name)]
[(list 'vecequiv (list '@ (list 'name name)))
(fprintf anomaly "; LATER vecequiv ~s~n" item)]
[ _ (fprintf anomaly "; TODO: unknown command item ~s~n" item) ]
))
(when (null? name)
#;(fprintf anomaly "; TODO: no name in command definition~n")
(fprintf anomaly "; TODO: best try:~n #;")
)
(fprintf output "TODO: debug: Parameter list is ~s from command ~s~n" params command)
(fprintf trace "; DEBUGG ~s~n" (map parameter-type params))
(define args (params->ctypes params))
(define results (get-output-ctypes args))
(fprintf output "got results ~s from args ~s~n" results args)
(define rev-regular-type (cons '-> (map cdr args))) ; <><><><>
(define rev-type
(if (null? results)
(cons resulttype rev-regular-type)
(cons (cons 'values (cons 'result (map car results)))
(cons '-> (cons (list 'result ': resulttype) rev-regular-type)))
))
(fprintf output "!!!!! rev-type ~s~n" rev-type)
(fprintf output "~s~n"
(list 'define-gl name
(- (length params) (length results)) ; This is wroneg. I suspect is has to be altered when there are output parameters, but I don't really know.
(reverse rev-type) ; the ctype of the function
(cons '->> ; this part is still very wwrong and currently generates gibberish.
(reverse (cons (racket-predicate resulttype)
(map racket-predicate ; <><><>
#;(map parameter-type params)
(map caddr (params->ctypes params))
)
)))
(if (equal? group "ErrorCode") 'void 'check-gl-error)
; TODO: when to generate check-gl-error?
; glGetError has void instead of check-gl-error in this spot
; in the old binding.
; many functions have check-gl-error
; Presumably this is to know when to test for errors on function return
; an connect with Rackets error handling.
; Maybe ... group="ErrorCode" as a prototype attribute should tell me to generate void instead of check-gl-error.
)
)
(unless (or (null? opcode) (null? glxtype))
(fprintf anomaly "; LATER: what to do with type ~s opcode ~s~n"
glxtype opcode))
)
(define (process-commands commands)
(for [(command commands)]
(match command
[(list '@ (list 'namespace namespace))
(fprintf anomaly "; LATER: namespace for commands is ~s~n" namespace)
]
[(cons 'command commanddef)
(process-command commanddef)]
[(cons (cons 'namespace spacedef) rest)
(fprintf "; TODO: namespace~n")]
[(cons (cons '@ stuff) rest)
(fprintf anomaly "; TODO: at-item in command list ~s~n" stuff)]
['() '()]
[ _ (fprintf anomaly "; TODO: unrecognised command~s~n" command)]
))
)
(define (process-regitem item)
(match item
[(cons 'comment rest) (process-comment rest)]
[(cons 'types rest) (process-types rest)]
[(cons 'groups rest) (process-groups rest)]
[(cons 'enums rest) (if do-enums (process-enums rest) void)]
[(cons 'commands rest) (process-commands rest)]
[ _ (fprintf anomaly "; TODO: strange registry item ~s~n" item)]
))
(define (process-registry reg)
(for [(item reg)]
(process-regitem item)
)
)
(define (find-registry spec)
(match spec
[(cons '*TOP*
(cons (cons '*PI* pi)
(list(cons 'registry stuff )))) stuff
]
[ _ (cons 'nope: spec)]
))
(define (read-spec)
(define in (open-input-file "/home/hendrik/dv/opengl-project/RacketGL/opengl/api/gl.xml"))
(define spec (ssax:xml->sxml in '()))
(close-input-port in)
spec
)
(process-registry
(find-registry
(read-spec)
))
(close-output-port output)
(println "done")
| false |
221ac00849ec6611f54dc3060676683217cddbdc | 95d543eae5db8c2a96bbe79fa765d07e12069e3c | /test/simple-test.rkt | 05b692d4a8ce542a28961ef8641e670e44da2a62 | []
| no_license | ryandrew14/mel | 88e35a1c54e28df6a3e016397c6be5681ec583a2 | 265b7974348a0f4b3ae2821de5a166f72fea6d65 | refs/heads/master | 2021-01-25T09:44:21.863039 | 2018-04-16T23:18:34 | 2018-04-16T23:18:34 | 123,314,816 | 6 | 1 | null | 2018-03-10T02:54:34 | 2018-02-28T16:55:47 | null | UTF-8 | Racket | false | false | 234 | rkt | simple-test.rkt | #lang s-exp "../lib/mel.rkt"
(tempo 80)
(sequence a
[rest 1]
[play kick #:repeat: 8]
[play clap #:rate 0.5])
(sequence b
[play hihat #:stretch 2])
(song
[a from 0 to 20]
[b from 10 to 20]) | false |
ee417494a1c90546732c12ab46055ff54af4efbe | de5c02213e527e66a2e463a04997ea45b6b8c6b6 | /sentry-doc/info.rkt | ceb1014d32560c9cfadf52c6bbeb828a4e2aa32f | [
"BSD-3-Clause"
]
| permissive | Bogdanp/racket-sentry | e2f8ec29acf0300f3235e73e53dfb1b9998bbf1e | 8cc862858376ed2e80c70e8c25ae88d3f3953906 | refs/heads/master | 2023-07-28T18:40:16.926984 | 2023-07-09T11:28:43 | 2023-07-09T11:28:43 | 194,729,650 | 7 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 464 | rkt | info.rkt | #lang info
(define license 'BSD-3-Clause)
(define collection "sentry")
(define scribblings '(("scribblings/sentry.scrbl" () ("Web Development"))))
(define deps '("base"))
(define build-deps '("gregor-lib"
"sentry-lib"
"scribble-lib"
"web-server-lib"
"gregor-doc"
"racket-doc"
"web-server-doc"))
(define update-implies '("sentry-lib"))
| false |
7551c861735b2fd0d05d9b56b5d041019f729cfe | 98fd12cbf428dda4c673987ff64ace5e558874c4 | /paip/gregr/greg-6.rkt | ff89292c56a686264c9847693eef8a2dcb8123d6 | [
"Unlicense"
]
| permissive | CompSciCabal/SMRTYPRTY | 397645d909ff1c3d1517b44a1bb0173195b0616e | a8e2c5049199635fecce7b7f70a2225cda6558d8 | refs/heads/master | 2021-12-30T04:50:30.599471 | 2021-12-27T23:50:16 | 2021-12-27T23:50:16 | 13,666,108 | 66 | 11 | Unlicense | 2019-05-13T03:45:42 | 2013-10-18T01:26:44 | Racket | UTF-8 | Racket | false | false | 21,419 | rkt | greg-6.rkt | #lang racket
(print-as-expression #f)
;(pretty-print-abbreviate-read-macros #f)
(define-syntax example
(syntax-rules ()
((_ e) (begin (newline)
(pretty-print 'e)
(displayln "==>")
(pretty-print e)))))
(define (sub* env d)
(define (loop d) (sub* env d))
(cond ((assoc d env) => (lambda (old-new) (cdr old-new)))
((pair? d) (cons (loop (car d)) (loop (cdr d))))
((vector? d) (vector-map loop d))
(else d)))
(define (var? x)
(and (symbol? x) (string-prefix? (symbol->string x) "?")))
(define (var-match env pattern input)
(define existing (assoc pattern env))
(if existing
(and (equal? (cdr existing) input) env)
(cons (cons pattern input) env)))
(define (segment-pattern? pattern)
(and (pair? pattern) (pair? (car pattern))
(assoc (car (car pattern)) segment-match-table)))
(define (segment-match env pattern input)
((cdr (assoc (car (car pattern)) segment-match-table))
env pattern input))
(define (single-pattern? pattern)
(and (pair? pattern)
(assoc (car pattern) single-match-table)))
(define (single-match env pattern input)
((cdr (assoc (car pattern) single-match-table))
env (cdr pattern) input))
(define (pat-match/env env pattern input)
(and env
(cond ((var? pattern) (var-match env pattern input))
((segment-pattern? pattern) (segment-match env pattern input))
((single-pattern? pattern) (single-match env pattern input))
((and (pair? pattern) (pair? input))
(pat-match/env (pat-match/env env (car pattern) (car input))
(cdr pattern) (cdr input)))
(else (and (equal? pattern input) env)))))
(define (pat-match pattern input) (pat-match/env '() pattern input))
(define (match-literal env quoted input)
(and (equal? (car quoted) input) env))
(define (match-is env var-and-pred input)
(define vr (car var-and-pred))
(define is? (cadr var-and-pred))
(define e2 (pat-match/env env vr input))
(and e2 ((eval is? (make-base-namespace)) input) e2))
(define (match-and env patterns input)
(and env (if (null? patterns) env
(match-and (pat-match/env env (car patterns) input)
(cdr patterns) input))))
(define (match-or env patterns input)
(and (pair? patterns)
(or (pat-match/env env (car patterns) input)
(match-or env (cdr patterns) input))))
(define (match-not env patterns input)
(and (not (match-or env patterns input)) env))
(define (segment-match-*+ env pattern input min-count)
(define seg-var (cadar pattern))
(define pat (cdr pattern))
(define binding (assoc seg-var env))
(if binding
;; For efficiency as mentioned in exercise 5.13.
(and (list? binding) (<= min-count (length binding))
(let loop ((input input) (binding binding))
(cond ((null? binding) (pat-match/env env pat input))
((pair? binding) (and (pair? input)
(equal? (car binding) (car input))
(loop (cdr input) (cdr binding))))
(else #f))))
(let loop ((count min-count) (input input) (seg '()))
(cond ((= 0 count)
(let loop ((input input) (seg seg))
(define e2 (pat-match/env env pat input))
(cond ((and e2 (var-match e2 seg-var (reverse seg))))
((pair? input) (loop (cdr input) (cons (car input) seg)))
(else #f))))
((pair? input)
(loop (- count 1) (cdr input) (cons (car input) seg)))
(else #f)))))
(define (segment-match-* env pattern input)
(segment-match-*+ env pattern input 0))
(define (segment-match-+ env pattern input)
(segment-match-*+ env pattern input 1))
(define (segment-match-? env pattern input)
(define seg-var (cadar pattern))
(define pat (cdr pattern))
;; Swap these to minimize greed.
(or (pat-match/env env (cons seg-var pat) input)
(pat-match/env env pat input)))
(define (match-if env pattern input)
(and (eval `(let ,(map (lambda (kv) `(,(car kv) ,(cdr kv))) env)
,(cadar pattern))
(make-base-namespace))
(pat-match/env env (cdr pattern) input)))
(define single-match-table
`((?quote . ,match-literal)
(?is . ,match-is)
(?or . ,match-or)
(?and . ,match-and)
(?not . ,match-not)))
(define segment-match-table
`((?* . ,segment-match-*)
(?+ . ,segment-match-+)
(?? . ,segment-match-?)
(?if . ,match-if)))
(example (pat-match '(x = (?is ?n number?)) '(x = 34)))
(example (pat-match '(x = (?is ?n number?)) '(x = x)))
(example (pat-match '(?x (?or < = >) ?y) '(3 < 4)))
(example (pat-match '(x = (?and (?is ?n number?) (?is ?n odd?)))
'(x = 3)))
(example (pat-match '(x = (?and (?is ?n number?) (?is ?n odd?)))
'(x = 2)))
(example (pat-match '(x = (?and (?is ?n number?) (?is ?n odd?)))
'(x = x)))
(example (pat-match '(?x /= (?not ?x)) '(3 /= 4)))
(example (pat-match '(?x > ?y (?if (> ?x ?y))) '(4 > 3)))
(example (pat-match '(a (?* ?x) d) '(a b c d)))
(example (pat-match '(a (?* ?x) (?* ?y) d) '(a b c d)))
(example (pat-match '(a (?* ?x) (?* ?y) ?x ?y) '(a b c d (b c) (d))))
(example (pat-match '(?x ?op ?y is ?z (?if (equal? (?op ?x ?y) ?z)))
'(3 + 4 is 7)))
(example (pat-match '(?x ?op ?y (?if (?op ?x ?y)))
'(3 > 4)))
(example (pat-match '(?x ?op ?y (?if (?op ?x ?y)))
'(3 < 4)))
(define (rule-system rule-match rule-if rule-then action)
(list rule-match rule-if rule-then action))
(define (rule-based-translator system input rules)
(define rule-match (car system))
(define rule-if (cadr system))
(define rule-then (caddr system))
(define action (cadddr system))
(ormap (lambda (rule)
(define result (rule-match (rule-if rule) input))
(and result (action result (rule-then rule))))
rules))
;; Exercise 6.6
(example (pat-match '(?one ?two ?three) '(?one ?two ?three)))
(example (pat-match '(?one (?quote ?two) ?three) '(?one ?two ?three)))
(example (pat-match '(?one (?quote ?two) ?three) '(?one two ?three)))
;; TODO: use this in chapter 5.
;(define eliza-rule-system
;(rule-system pat-match car cdr
;(lambda (env responses)
;(sub* (switch-viewpoint env)
;(random-elt responses)))))
;(define (use-eliza-rules input)
;(rule-based-translator eliza-rule-system input eliza-rules))
(define debug-search? #f)
;; (set! debug-search? #t) wherever you'd like to step through search examples.
(define debug-proj #f)
(define (debug-search states)
(when debug-search? (printf ";; States: ~a\n"
(if debug-proj (map debug-proj states) states))
(read-line)))
(define (tree-search states goal? successors combine)
(debug-search states)
(cond ((null? states) #f)
((goal? (car states)) (car states))
(else (tree-search (combine (successors (car states)) (cdr states))
goal? successors combine))))
(define (prepend xs ys) (append ys xs))
(define (depth-first-search states goal? successors)
(tree-search states goal? successors append))
(define (breadth-first-search states goal? successors)
(tree-search states goal? successors prepend))
(define (binary-tree x) (list (* 2 x) (+ 1 (* 2 x))))
(define (is value) (lambda (x) (equal? x value)))
(define (is/proj value proj ?) (lambda (x) (? (proj x) value)))
;(example (depth-first-search '(1) (is 12) binary-tree))
(example (breadth-first-search '(1) (is 12) binary-tree))
(define (finite-binary-tree n)
(lambda (x)
(filter-not (lambda (child) (> child n)) (binary-tree x))))
(example (depth-first-search '(1) (is 12) (finite-binary-tree 15)))
(define (diff n) (lambda (x) (abs (- x n))))
;; Exercise 6.9
(define (merge cost ps qs)
(cond
((null? ps) qs)
((null? qs) ps)
((< (cost (car qs))
(cost (car ps))) (cons (car qs) (merge cost ps (cdr qs))))
(else (cons (car ps) (merge cost (cdr ps) qs)))))
(define (sorter cost)
(lambda (new old)
;(sort (append new old) (lambda (a b) (< (cost a) (cost b))))
(merge cost (sort new (lambda (a b) (< (cost a) (cost b)))) old)))
(define (best-first-search states goal? successors cost)
(tree-search states goal? successors (sorter cost)))
(example (best-first-search '(1) (is 12) binary-tree (diff 12)))
(define max-fixnum (- (expt 2 62) 1))
(define (price-is-right price)
(lambda (x) (if (> x price) max-fixnum (- price x))))
(example (best-first-search '(1) (is 12) binary-tree (price-is-right 12)))
(define (beam-search states goal? successors cost beam-width)
(tree-search states goal? successors
(lambda (new old)
(define sorted ((sorter cost) new old))
(if (> beam-width (length sorted))
sorted
(take sorted beam-width)))))
(example (beam-search '(1) (is 12) binary-tree (price-is-right 12) 2))
;(set! debug-search? #t)
;(example (beam-search '(1) (is 12) binary-tree (diff 12) 2))
(example (beam-search '(1) (is 12) binary-tree (diff 12) 3))
(define (city-name c) (car c))
(define (city-long c) (cadr c))
(define (city-lat c) (caddr c))
(define cities
;; (name longitude latitude)
'((Atlanta 84.23 33.45) (Los-Angeles 118.15 34.03)
(Boston 71.05 42.21) (Memphis 90.03 35.09)
(Chicago 87.37 41.50) (New-York 73.58 40.47)
(Denver 105.00 39.45) (Oklahoma-City 97.28 35.26)
(Eugene 123.05 44.03) (Pittsburgh 79.57 40.27)
(Flagstaff 111.41 35.13) (Quebec 71.11 46.49)
(Grand-Jct 108.37 39.05) (Reno 119.49 39.30)
(Houston 105.00 34.00) (San-Francisco 122.26 37.47)
(Indianapolis 86.10 39.46) (Tampa 82.27 27.57)
(Jacksonville 81.40 30.22) (Victoria 123.21 48.25)
(Kansas-City 94.35 39.06) (Wilmington 77.57 34.14)))
(define (neighbors city)
(filter (lambda (c) (and (not (equal? c city))
(< (air-distance c city) 1000.0)))
cities))
(define (city name) (assoc name cities))
(define (trip1 start dest)
(beam-search (list start) (is dest) neighbors
(lambda (c) (air-distance c dest)) 1))
(define earth-diameter 12765.0)
(define (air-distance c1 c2)
(define d (distance (xyz-coords c1) (xyz-coords c2)))
(* earth-diameter (asin (/ d 2))))
(define (xyz-coords city)
(define psi (deg->radians (city-lat city)))
(define phi (deg->radians (city-long city)))
(list (* (cos psi) (cos phi))
(* (cos psi) (sin phi))
(sin psi)))
(define (distance p1 p2)
(sqrt (foldl + 0 (map (lambda (a b) (expt (- a b) 2)) p1 p2))))
(define (deg->radians deg)
(define trunc (truncate deg))
(* (+ trunc (* (- deg trunc) 100/60)) pi 1/180))
(example (trip1 (city 'San-Francisco) (city 'Boston)))
(example (trip1 (city 'Boston) (city 'San-Francisco)))
(define (path state previous cost-so-far total-cost)
(vector state previous cost-so-far total-cost))
(define (path-state p) (vector-ref p 0))
(define (path-previous p) (vector-ref p 1))
(define (path-cost-so-far p) (vector-ref p 2))
(define (path-total-cost p) (vector-ref p 3))
(define (path/state state) (vector state #f 0 0))
(define (trip2 start dest beam-width)
(beam-search (list (path/state start))
(is/proj dest path-state equal?)
(path-saver neighbors air-distance
(lambda (c) (air-distance c dest)))
path-total-cost
beam-width))
(define (path-saver successors cost cost-remaining)
(lambda (old-path)
(define old-state (path-state old-path))
(map (lambda (new-state)
(define old-cost (+ (path-cost-so-far old-path)
(cost old-state new-state)))
(path new-state old-path old-cost
(+ old-cost (cost-remaining new-state))))
(successors old-state))))
(define (show-path path)
(format "#<Path to ~a cost ~a>" (path-state path)
(~r (path-total-cost path) #:precision 1)))
(define (show-city-path path)
(define names (reverse (map-path city-name path)))
(format "#<Path ~a km: ~a~a>" (path-total-cost path)
(car names)
(string-append*
(map (lambda (n) (string-append " - " (symbol->string n)))
(cdr names)))))
(define (map-path f path)
(if path (cons (f (path-state path))
(map-path f (path-previous path)))
'()))
;(set! debug-search? #t)
(set! debug-proj show-path)
(example (show-city-path (trip2 (city 'San-Francisco) (city 'Boston) 1)))
(example (show-city-path (trip2 (city 'Boston) (city 'San-Francisco) 1)))
(example (show-city-path (trip2 (city 'Boston) (city 'San-Francisco) 3)))
(set! debug-proj #f)
(define (iter-wide-search states goal? successors cost width max-width)
(when debug-search? (printf "; Width: ~a\n" width))
(unless (> width max-width)
(or (beam-search states goal? successors cost width)
(iter-wide-search states goal? successors cost
(+ width 1) max-width))))
(example (iter-wide-search '(1) (is 12) (finite-binary-tree 15) (diff 12)
1 100))
(define (adjoin x xs =?)
(if (memf (lambda (y) (=? x y)) xs)
xs
(cons x xs)))
(define (graph-search states goal? successors combine state=? old-states)
(debug-search states)
(cond ((null? states) #f)
((goal? (car states)) (car states))
(else (graph-search
(combine (new-states states successors state=? old-states)
(cdr states))
goal? successors combine state=?
(adjoin (car states) old-states state=?)))))
(define (new-states states successors state=? old-states)
(define (mem state states) (memf (lambda (s) (state=? s state)) states))
(filter-not (lambda (state) (or (mem state states) (mem state old-states)))
(successors (car states))))
(define (next2 x) (list (+ x 1) (+ x 2)))
(define (a*-search paths goal? successors cost cost-left state=? old-paths)
(debug-search (map show-path paths))
(cond ((null? paths) #f)
((goal? (path-state (car paths))) (car paths))
(else
(let* ((p (car paths)) (state (path-state p)))
(let loop0 ((states (successors state))
(paths (cdr paths))
(old-paths (insert-path p old-paths)))
(define (loop paths old-paths)
(loop0 (cdr states) paths old-paths))
(if (null? states) (a*-search paths goal? successors
cost cost-left state=? old-paths)
(let* ((state2 (car states))
(cost (+ (path-cost-so-far p) (cost state state2)))
(cost2 (cost-left state2))
(p2 (path state2 p cost (+ cost cost2))))
(cond
((find-path state2 paths state=?)
=> (lambda (old)
(if (path<? p2 old)
(loop (insert-path p2 (remove old paths))
old-paths)
(loop paths old-paths))))
((find-path state2 old-paths state=?)
=> (lambda (old)
(if (path<? p2 old)
(loop (insert-path p2 paths)
(remove old old-paths))
(loop paths old-paths))))
(else (loop (insert-path p2 paths) old-paths))))))))))
(define (find-path state paths state=?)
(findf (lambda (p) (state=? (path-state p) state)) paths))
(define (path<? p1 p2) (< (path-total-cost p1) (path-total-cost p2)))
(define (merge-paths ps qs)
(cond
((null? ps) qs)
((null? qs) ps)
((path<? (car qs) (car ps)) (cons (car qs) (merge-paths ps (cdr qs))))
(else (cons (car ps) (merge-paths (cdr ps) qs)))))
(define (insert-path p paths) (merge-paths (list p) paths))
(define (path-states p) (map-path (lambda (x) x) p))
(example (tree-search '(1) (is 6) next2 prepend))
(example (graph-search '(1) (is 6) next2 prepend equal? '()))
(example (path-states (a*-search (list (path/state 1)) (is 6) next2
(lambda (x y) 1) (diff 6) equal? '())))
(define (search-all start goal? successors cost beam-width)
(define solutions '())
(beam-search (list start)
(lambda (x)
(when (goal? x) (set! solutions (cons x solutions)))
#f)
successors cost beam-width)
solutions)
(define (subset? xs ys) (andmap (lambda (x) (member x ys)) xs))
(define (executing? x) (and (pair? x) (eq? 'executing (car x))))
(struct op (action preconds add-list del-list) #:prefab)
(define *ops* #f)
(define (search-gps ops start goal beam-width)
(define (cost state)
(+ (length (filter executing? state))
(length (filter (lambda (con) (not (member con state)))
goal))))
(define old-ops *ops*)
(set! *ops* ops)
(define result
(beam-search (list start) (lambda (state) (subset? goal state))
gps-successors cost beam-width))
(set! *ops* old-ops)
(and result (filter executing? result)))
(define (gps-successors state)
(map (lambda (op)
(append (filter-not (lambda (x) (member x (op-del-list op))) state)
(cons (list 'executing (op-action op)) (op-add-list op))))
(applicable-ops state)))
(define (applicable-ops state)
(filter (lambda (op) (subset? (op-preconds op) state)) *ops*))
(define (make-block-ops blocks)
(define (move-op a b c)
(op `(move ,a from ,b to ,c)
`((space on ,a) (space on ,c) (,a on ,b))
(move-ons a b c)
(move-ons a c b)))
(define (move-ons a b c)
(if (eq? b 'table)
`((,a on ,c))
`((,a on ,c) (space on ,b))))
(append*
(map (lambda (a)
(append*
(map (lambda (b)
(if (equal? a b) '()
(append*
(cons (list (move-op a b 'table)
(move-op a 'table b))
(map (lambda (c)
(append (if (or (equal? c a)
(equal? c b))
'()
(list (move-op a b c)))))
blocks))))) blocks))) blocks)))
(define start '((c on a) (a on table) (b on table) (space on c)
(space on b) (space on table)))
(example (search-gps (make-block-ops '(a b c)) start '((a on b) (b on c)) 10))
(example (search-gps (make-block-ops '(a b c)) start '((b on c) (a on b)) 10))
;; Exercise 6.11
(define (beam-search/n n start goal? successors cost beam-width)
(define solutions '())
(when (< 0 n)
(beam-search (list start)
(lambda (x)
(and (goal? x)
(set! n (- n 1))
(set! solutions (cons x solutions))
(= 0 n)
x))
successors cost beam-width))
solutions)
(example (beam-search/n 1 1 (is 12) binary-tree (price-is-right 12) 2))
;(example (beam-search/n 2 1 (is 12) binary-tree (price-is-right 12) 2))
(example (beam-search/n 5 1 (is 6) next2 (price-is-right 6) 20))
;; Exercise 6.15
(define (search-gps-backwards ops start goal beam-width)
(define (cost state)
(+ (length (filter (lambda (con) (not (member con state))) start))
(- (length state)
(length (filter (lambda (con) (member con state)) start)))))
(define old-ops *ops*)
(set! *ops* ops)
(define result
(beam-search (list goal)
(lambda (state)
(define non-actions (filter-not executing? state))
(and (subset? start non-actions)
(subset? non-actions start)))
gps-backwards-successors cost beam-width))
(set! *ops* old-ops)
(and result (filter executing? result)))
(define (gps-backwards-successors state)
(map (lambda (op)
(append (cons (list 'executing (op-action op))
(filter-not (lambda (x) (member x (op-add-list op)))
state))
(foldl (lambda (p acc) (if (member p acc) acc (cons p acc)))
(op-del-list op) (op-preconds op))))
(applicable-ops-backwards state)))
(define (applicable-ops-backwards state)
(filter (lambda (op)
(null? (filter (lambda (x) (member x state)) (op-del-list op))))
*ops*))
(example (search-gps-backwards
(make-block-ops '(a b c)) start '((a on b) (b on c)) 10))
(example (search-gps-backwards
(make-block-ops '(a b c)) start '((b on c) (a on b)) 10))
| true |
16a397bc0bf2b0c0a990bff92eeeb87b4c2ed8e0 | bdde8e6a31d70a992cb621a173c61c9f7392d1c1 | /rackjure/alist.rkt | de42db8c4ffc6dc0bb59fb378f4f1ac9f6b59751 | [
"BSD-2-Clause",
"BSD-3-Clause"
]
| permissive | greghendershott/rackjure | 4fe2e0e836f01d181c7691d28019f7ffc20f9592 | 9f7c74f5a499f71407890037839a3fa3b178dcef | refs/heads/master | 2022-11-30T00:55:01.225989 | 2022-11-25T18:20:52 | 2022-11-25T18:20:52 | 8,044,078 | 215 | 19 | null | 2018-05-25T02:05:16 | 2013-02-06T03:48:24 | Racket | UTF-8 | Racket | false | false | 577 | rkt | alist.rkt | ;; Copyright (c) 2013-2022 by Greg Hendershott.
;; SPDX-License-Identifier: BSD-2-Clause
#lang racket/base
(provide alist alist?)
(require racket/match)
(define (alist . xs)
(match xs
[(list* k v more) (cons (cons k v) (apply alist more))]
[(list x) (raise-arity-error 'alist (arity-at-least 2) x)]
[(list) (list)]))
(define (alist? xs)
(and (list? xs)
(for/and ([x (in-list xs)])
(pair? x))))
(module+ test
(require rackunit)
(check-equal? (alist 1 2 3 4 5 6) '([1 . 2][3 . 4][5 . 6]))
(check-equal? (alist) '()))
| false |
cdf2bf8831ebf35e3b8505197f771ac21f3cd2c9 | 394f948952cddcc2c19e81e329f887b1109839b3 | /compose.rkt | b2f22b534e35e2850133663b66219e48dfcb4566 | []
| no_license | dannypsnl-fork/multi-lang-comp | f51570d71a0790b768de7e8f66151b2d9fe95b12 | 08b65d40b31693b4a65decf529a4c180054eab34 | refs/heads/main | 2023-03-01T13:57:28.729418 | 2021-02-11T02:19:27 | 2021-02-11T02:19:27 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 801 | rkt | compose.rkt | #lang racket/base
(require
redex/reduction-semantics
"lambda-s.rkt"
"anf.rkt"
"cc.rkt"
"hoist.rkt"
"specify.rkt"
"code-gen.rkt"
"al.rkt")
;(define-union-language CompileL ANFL CCL)
;
;(define anf-compile-> (extend-reduction-relation anf-> CompileL))
;(define cc-compile-> (extend-reduction-relation cc-> CompileL))
;
;(define compile-> (union-reduction-relations anf-compile-> cc-compile->))
;
;(define anf-compile->+ (extend-reduction-relation anf->+ CompileL))
;(define cc-compile->+ (extend-reduction-relation cc->+ CompileL))
;
;(define compile->+ (union-reduction-relations anf-compile->+ cc-compile->+))
(current-cache-all? #t)
(define (compile t)
(for/fold ([t t])
([pass (list anf->+ cc->+ h-> s->+ cg->+ #;flatten->+)])
(car (apply-reduction-relation* pass t))))
| false |
599fdb60ec7a1f3340fb00b0ff2312c67e952a35 | c161c2096ff80424ef06d144dacdb0fc23e25635 | /chapter4/exercise/ex4.20.rkt | cf684d603369575ad4c8f04eafd381035a0136fc | []
| no_license | tangshipoetry/SICP | f674e4be44dfe905da4a8fc938b0f0460e061dc8 | fae33da93746c3f1fc92e4d22ccbc1153cce6ac9 | refs/heads/master | 2020-03-10T06:55:29.711600 | 2018-07-16T00:17:08 | 2018-07-16T00:17:08 | 129,242,982 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,974 | rkt | ex4.20.rkt | #lang racket
#|
(define (f x)
(define (even? n) (if (= n 0) true (odd? (- n 1))))
(define (odd? n) (if (= n 0) false (even? (- n 1))))
(even? x))
|#
#|
(define (f x)
(letrec
((even? (lambda (n)
(if (= n 0) true (odd? (- n 1)))))
(odd? (lambda (n)
(if (= n 0) false (even? (- n 1))))))
(even? x)))
(define (factrial n)
(letrec
((fact (lambda (n)
(if (= n 1) 1 (* n (fact (- n 1)))))))
(fact n)))
|#
(define (letrec->let exp)
(let* ([vars (bind-unassign (map bind-assignment (letrec-vars exp)))]
[bind-vals (letrec-val exp)])
(make-let vars (make-begin (appnd (list vars (map assign-map (letrec-vars exp) bind-vals))
(letrec-body exp))))))
;网上的
; a
(define (letrec? exp)
(tagged-list exp 'letrec))
(define (letrec-bindings exp)
(cadr exp))
(define (letrec-binding-vars exp)
(map car (letrec-bindings exp)))
(define (letrec-binding-vals exp)
(map cadr (letrec-bindings exp)))
(define (letrec-body exp)
(cddr exp))
(define (make-unassigned-bindings vars)
(map (lambda (var) (cons var '*unassigned*)) vars))
(define (make-set-clauses vars vals)
(map (lambda (var val) (list 'set! var val)) vars vals))
(define (letrec->let exp)
(let ((vars (letrec-binding-vars exp))
(vals (letrec-binding-vals exp)))
(make-let (make-unassigned-bindings vars)
(append (make-set-clauses vars vals)
(letrec-body exp)))))
; b)
;let 就相当于是一次过程应用,展现形式如下:
((lambda (even? odd?)
<rest of body of f>)
(lambda (n) <body of even? including call to odd?>)
(lambda (n) <body of odd? including call to even?>))
;这里 lambda 中的两个参数 even? odd? 的名字是可以随意更改的，但是在下面的两个 lambda 参数中，even? odd? 是预先定义好的，无法修改，所以这时会有错误。
| false |
3b947a124f10691c293938dac5f62a71972f6e37 | e08e0a73c39bdc8449e6d82933bee8354562ad35 | /deinprogramm/deinprogramm/DMdA-vanilla/lang/reader.rkt | 2a3d0fa8c72fa7c9541de82d79b019211b069c54 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
]
| permissive | racket/deinprogramm | fe8bc424a95648a2bfa1a6a974f4729b0dfbd844 | fecdee4ba12a0f425d3ef9e0c316747f33378e81 | refs/heads/master | 2023-08-17T17:33:29.457959 | 2023-07-07T12:09:51 | 2023-07-07T12:09:51 | 27,381,246 | 6 | 9 | NOASSERTION | 2023-02-05T10:15:32 | 2014-12-01T13:42:59 | Racket | UTF-8 | Racket | false | false | 59 | rkt | reader.rkt | #lang s-exp syntax/module-reader
deinprogramm/DMdA-vanilla
| false |
2a86e650e1f56216ba81d83a4d4a1829cac16955 | d0d656b7729bd95d688e04be38dde7d8cde19d3d | /1/1.2/solution.1.28.rkt | 7f9cf2138de1a3b6ba23a3ea776c56572974ba70 | [
"MIT"
]
| permissive | search-good-project/SICP-in-Racket | f0157335a1d39c8ff4231e579fc13b0297c07e65 | daaae62db83bf8e911f4b8dbd00f8509113f557a | refs/heads/master | 2022-02-20T01:21:33.633182 | 2019-09-16T03:58:02 | 2019-09-16T03:58:02 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 2,032 | rkt | solution.1.28.rkt | #lang sicp
;; `遇到了"1取模n的非平凡平方根"` 的含义是
;; 找到了一个 x!=1 && x!=n-1, 但是 x^2%n=1
;; 在 expmod 过程中，肯定会遇到 x^2%n=? 的计算。
;; 如果 x 是非平凡平方根，则可以断定 n 不是素数。
(define (miller-rabin-expmod base exp n)
(define (square-mod-check x)
(define (check-nontrivial-sqrt x square-mod)
(if (and (= square-mod 1)
(not (= x 1))
(not (= x (- n 1))))
0 ;; finde nontrivial square root
square-mod))
(check-nontrivial-sqrt x (remainder (square x) n)))
(cond ((= exp 0) 1)
((even? exp) (square-mod-check
(miller-rabin-expmod base (/ exp 2) n)))
(else
(remainder (* base (miller-rabin-expmod base (- exp 1) n))
n))))
(define (miller-rabin-test n)
(define (try a)
(define (check x)
(and (not (= x 0)) ;; not find nontrivial square root
(= x 1)))
(check (miller-rabin-expmod a (- n 1) n)))
(try (+ 1 (random (- n 1)))))
(define (fast-prime? n times)
(cond ((= times 0) true)
((miller-rabin-test n) (fast-prime? n (- times 1)))
(else false)))
(define (miller-rabin-prime? n)
(fast-prime? n 100))
; ------
(define (real-prime? n)
(= n (smallest-divisor n)))
(define (smallest-divisor n)
(find-divisor n 2))
(define (find-divisor n test-divisor)
(cond ((> (square test-divisor) n) n)
((divides? test-divisor n) test-divisor)
(else (find-divisor n (+ test-divisor 1)))))
(define (divides? d n)
(= (remainder n d)
0))
(define (square a)
(* a a))
; -----
(define (check-carmichael n)
(define (carmichael? n)
(and (miller-rabin-prime? n)
(not (real-prime? n))))
(display n)
(display " Carmichael?: ")
(display (carmichael? n))
(newline))
(check-carmichael 561)
(check-carmichael 1105)
(check-carmichael 1729)
(check-carmichael 2465)
(check-carmichael 2821)
(check-carmichael 6601)
| false |
ef2a6e20d356b6e73bbbb9729b6b24adfd446c28 | d17943098180a308ae17ad96208402e49364708f | /programs/pac-man/pac-man.rkt | ca93c35dd4eb23df4df42ae24eef3b0757520ac8 | []
| no_license | dyoo/benchmark | b3f4f39714cc51e1f0bc176bc2fa973240cd09c0 | 5576fda204529e5754f6e1cc8ec8eee073e2952c | refs/heads/master | 2020-12-24T14:54:11.354541 | 2012-03-02T19:40:48 | 2012-03-02T19:40:48 | 1,483,546 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 8,233 | rkt | pac-man.rkt | #lang racket/base
(define-struct posn (x y))
;; Constants:
(define E " ") ;See CellValue data definition below
(define D "o") ;
(define W "M") ;
(define INIT-BOARD ;See Board data definition below
(vector (vector W W W W W W W W W W W W W)
(vector W D D D D D D D D D D D W)
(vector W D W D W W W W W D W D W)
(vector W D W D W D D D W D W D W)
(vector W D W D D D W D D D W D W)
(vector W D W W D W W W D W W D W)
(vector W D D D D D E D D D D D W)
(vector W W W W W W W W W W W W W)))
(define CELL-SIZE 20)
(define BOARD-WIDTH (* CELL-SIZE (vector-length (vector-ref INIT-BOARD 0))))
(define BOARD-HEIGHT (* CELL-SIZE (vector-length INIT-BOARD)))
(define SCORE-HEIGHT 30)
(define SCORE-TEXT-SIZE 20)
;; Data definitions:
;; Score is Natural
;; interp. dots eaten by pac-man since start of game
(define INIT-SCORE 0)
;; CellValue is one of:
;; - "empty"
;; - "dot"
;; - "wall"
;; interp. the content of a board cell
;; Direction is one of:
;; - "U"
;; - "D"
;; - "L"
;; - "R"
;; interp. direction that a sprite is facing
(define-struct sprite (pos dir) #:transparent)
;; Sprite is (make-sprite Posn Direction)
;; interp. the position in Board coordinates, and the direction of a sprite
(define INIT-PM (make-sprite (make-posn 6 6) "R"))
;; Board is (vectorof (vectorof CellValue))
;; interp. the game board
(define-struct gs (pm board score) #:transparent)
;; GameState is (make-gs Sprite Board Score)
;; interp. all parts of the pac-man game; pac-man, the current
;; board, and the current score
(define INIT-GS (make-gs INIT-PM INIT-BOARD INIT-SCORE))
;; Functions:
;; GameState -> GameState
;; runs the game
(define (main)
(begin
(tick INIT-GS)
(game-over? INIT-GS)
#;(big-bang INIT-GS
(on-tick tick .3)
;(on-key key-handler)
(on-tilt tilt-handler)
(stop-when game-over?)
(to-draw render))))
(define (run moves)
(letrec ([loop (lambda (board moves)
(cond
[(null? moves)
board]
[else
(loop
;; simulating the rapid arrival of movement events
(tick (repeat 100 (lambda () (set-pm-dir board (car moves)))))
(cdr moves))]))])
(loop INIT-GS moves)))
(define (repeat n thunk)
(cond
[(< n 0)
(thunk)]
[else
(thunk)
(repeat (- n 1) thunk)]))
(define (sample-run)
(run '("L" "L" "L" "L" "L"
"U" "U" "U" "U" "U"
"R" "R" "R" "R" "R" "R" "R" "R" "R" "R"
"D" "D" "D" "D" "D" "D"
"L" "L" "L"
"U" "U" "L" "U" "L" "L")))
;; Board Natural Natural -> CellValue
;; looks up the value of a Board cell
(define (board-ref board x y)
(vector-ref (vector-ref board y) x))
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;; on-tick handler:
;; GameState -> GameState
;; advances the game
(define (tick gs)
(let* ([pm (gs-pm gs)]
[board (gs-board gs)]
[score (gs-score gs)]
[new-pm (tick-sprite pm board)]
[new-board (tick-board board new-pm)]
[new-score (tick-score board new-board score)])
(make-gs new-pm
new-board
new-score)))
;; Board Sprite -> Board
;; updates the board by removing a dot if pac-man is in a cell with a dot
(define (tick-board board pm)
(let* ([pos (sprite-pos pm)]
[x (posn-x pos)]
[y (posn-y pos)])
(if (string=? (board-ref board x y) D)
(new-board x y board)
board)))
;; Number Number Board -> Board
;; produces a new board with an empty cell at x, y
(define (new-board x y board)
(build-vector (vector-length board)
(lambda (j)
(build-vector (vector-length (vector-ref board j))
(lambda (i)
(if (and (= y j) (= x i))
E
(board-ref board i j)))))))
;; Board Board Score -> Score
;; increases the score if the board has changed
(define (tick-score last-board new-board score)
(if (equal? last-board new-board)
score
(add1 score)))
;; Sprite Board -> Sprite
;; updates sprite's position based on its direction
(define (tick-sprite sprite board)
(let* ([pos (sprite-pos sprite)]
[dir (sprite-dir sprite)]
[new-pos (move-posn pos dir)]
[new-x (posn-x new-pos)]
[new-y (posn-y new-pos)])
(make-sprite (cond [(string=? (board-ref board new-x new-y) E) new-pos]
[(string=? (board-ref board new-x new-y) W) pos]
[(string=? (board-ref board new-x new-y) D) new-pos])
dir)))
;; Posn Direction -> Posn
;; produces pac-man's new position based on its direction
(define (move-posn pos dir)
(let ([x (posn-x pos)]
[y (posn-y pos)])
(cond [(string=? dir "U") (make-posn x (sub1 y))]
[(string=? dir "D") (make-posn x (add1 y))]
[(string=? dir "L") (make-posn (sub1 x) y)]
[(string=? dir "R") (make-posn (add1 x) y)])))
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;; GameStateDirection -> GameState
;; changes pac-man's Direction to dir
(define (set-pm-dir gs dir)
(make-gs (make-sprite (sprite-pos (gs-pm gs)) dir)
(gs-board gs)
(gs-score gs)))
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;;-------------------------------------------------------------------------------------
;; stop-when handler:
;; GameState -> Boolean
;; determines if pac-man has eaten all the dots
(define (game-over? gs)
(empty-board? (gs-board gs)))
;; Board -> Boolean
;; determines if the board is empty
(define (empty-board? board)
(letrec ([;; Natural -> Boolean
;; determines if all rows have no dots
empty-rows?
(lambda (j)
(cond [(= j (vector-length board)) #t]
[else
(and (empty-row? (vector-ref board j) 0)
(empty-rows? (add1 j)))]))]
;; (vectorof CellValue) Natural -> Boolean
;; determines if a single row has no dots
[empty-row? (lambda (row i)
(cond [(= i (vector-length row)) #t]
[else
(and (not (string=? (vector-ref row i) D))
(empty-row? row (add1 i)))]))])
(empty-rows? 0)))
(define (display-board board)
(for-each (lambda (row)
(for-each display (vector->list row))
(newline))
(vector->list board)))
(let loop ([i 1000])
(cond [(> i 0)
(run '("L" "L" "L" "L" "L"
"U" "U" "U" "U" "U"
"R" "R" "R" "R" "R" "R" "R" "R" "R" "R"
"D" "D" "D" "D" "D" "D"
"L" "L" "L"
"U" "U" "L" "U"))
(loop (- i 1))]
[else
(let ([gs
(run '("L" "L" "L" "L" "L"
"U" "U" "U" "U" "U"
"R" "R" "R" "R" "R" "R" "R" "R" "R" "R"
"D" "D" "D" "D" "D" "D"
"L" "L" "L"
"U" "U" "L" "U"))])
(display (gs-score gs))
(newline)
(display-board (gs-board gs)))])) | false |
89784c65651d214a6e6552147b1b479f522d6005 | 2c819623a83d8c53b7282622429e344389ce4030 | /genc/genc.rkt | 36c7ab5d2551dd93af1095c5cf003685c1db2017 | []
| no_license | uw-unsat/jitsynth | 6bc97dd1ede9da42c0b9313a4766095345493adc | 69529e18d4a8d4dace884bfde91aa26b549523fa | refs/heads/master | 2022-05-29T05:38:57.129444 | 2020-05-01T19:35:32 | 2020-05-01T19:35:32 | 260,513,113 | 14 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 15,516 | rkt | genc.rkt | #lang rosette
; NOTE: Right now, I'm just outputting strings
; Do this less stupidly at some point
(require "../ams/machine.rkt"
"../common/case-hex.rkt"
"../common/file-utils.rkt"
"../common/data-utils.rkt")
(require pprint
racket/serialize)
(require (only-in rosette/base/core/polymorphic ite))
(require (only-in "../common/debug.rkt" [debugln common:debugln]))
(provide create-cfile
tgt-prog->cfunc
(struct-out cfunc))
(define DEBUG #t)
(define (debugln x)
(if DEBUG (common:debugln x) void))
(define helper-impls null)
(define (add-impl impl)
(set! helper-impls (cons impl helper-impls)))
(define all-cfuncs null)
(define (add-cfunc name)
(set! all-cfuncs (cons name all-cfuncs)))
; TODO seems to be doing something funny to #xff0
(define (bv->text bv)
(text (format "0x~x" (bitvector->natural bv))))
; TODO should I have some equality nonsense?
(serializable-struct cfunc (name params) #:transparent)
(define (read-cfunc dir filename)
(read-from-dir dir filename))
(define (write-cfunc dir filename cfunc)
(write-to-dir dir filename cfunc))
; TODO is this needed?
(define (name->text name)
(text (~a name)))
; TODO do some magic to auto indent
(define (cfunc->text my-cfunc)
(let* ([params (cfunc-params my-cfunc)]
; NOTE: I just have this in here b/c I messed up
; before and cached results are screwey
[params (if (list? params) params (list params))]
[name (cfunc-name my-cfunc)]
[params-docs
(if (null? params) (text "")
(h-append
(cparam->text (first params))
(h-concat
; TODO use apply-infix here
(for/list ([p (rest params)])
(h-append comma space (cparam->text p))))))])
(when (not (has-func? name))
(add-user-defined-func name))
(h-append (name->text name)
lparen
params-docs
rparen)))
(define (cparam->text param)
(if (cfunc? param) (cfunc->text param)
(if (bv? param) (bv->text param)
(text (~a param)))))
(define input-src-instr 'si)
(define cadd-impl
(v-append
; TODO extract 0-bl
(nest 4 (v-append (text "u64 cadd(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a + b);")))
(text "}")))
(add-cfunc 'cadd)
(add-impl cadd-impl)
(define (cadd a b bl)
(cfunc 'cadd (list a b bl)))
(define cmul-impl
(v-append
(nest 4 (v-append (text "u64 cmul(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a * b);")))
(text "}")))
(add-cfunc 'cmul)
(add-impl cmul-impl)
(define (cmul a b bl)
(cfunc 'cmul (list a b bl)))
(define clshr-impl
(v-append
(nest 4 (v-append (text "u64 clshr(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a >> b);")))
(text "}")))
(add-cfunc 'clshr)
(add-impl clshr-impl)
(define (clshr a b bl)
(cfunc 'clshr (list a b bl)))
(define cashr-impl
(v-append
(nest 4 (v-append (text "u64 cashr(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, ((s64) a) >> b);")))
(text "}")))
(add-cfunc 'cashr)
(add-impl cashr-impl)
(define (cashr a b bl)
(cfunc 'cashr (list a b bl)))
(define cshl-impl
(v-append
(nest 4 (v-append (text "u64 cshl(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a << b);")))
(text "}")))
(add-cfunc 'cshl)
(add-impl cshl-impl)
(define (cshl a b bl)
(cfunc 'cshl (list a b bl)))
(define cxor-impl
(v-append
(nest 4 (v-append (text "u64 cxor(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a ^ b);")))
(text "}")))
(add-cfunc 'cxor)
(add-impl cxor-impl)
(define (cxor a b bl)
(cfunc 'cxor (list a b bl)))
(define cor-impl
(v-append
(nest 4 (v-append (text "u64 cor(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a | b);")))
(text "}")))
(add-cfunc 'cor)
(add-impl cor-impl)
(define (cor a b bl)
(cfunc 'cor (list a b bl)))
(define cand-impl
(v-append
(nest 4 (v-append (text "u64 cand(u64 a, u64 b, u64 bl) {")
(text "return cextract(bl - 1, 0, a & b);")))
(text "}")))
(add-cfunc 'cand)
(add-impl cand-impl)
(define (cand a b bl)
(cfunc 'cand (list a b bl)))
(define cneg-impl
(v-append
(nest 4 (v-append (text "u64 cneg(u64 a, u64 bl) {")
(text "return cextract(bl - 1, 0, -a);")))
(text "}")))
(add-cfunc 'cneg)
(add-impl cneg-impl)
(define (cneg a bl)
(cfunc 'cneg (list a bl)))
(define ceq-impl
(v-append
(nest 4 (v-append (text "bool ceq(u64 a, u64 b) {")
(text "return a == b;")))
(text "}")))
(add-cfunc 'ceq)
(add-impl ceq-impl)
(define (ceq a b)
(cfunc 'ceq (list a b)))
(define cite-impl
(v-append
(nest 4 (v-append (text "u64 cite(bool cond, u64 a, u64 b) {")
(text "return cond ? a : b;")))
(text "}")))
(add-cfunc 'cite)
(add-impl cite-impl)
(define (cite ite-cond a b)
(cfunc 'cite (list ite-cond a b)))
(define cconcat-impl
(v-append
(nest 4 (v-append (text "u64 cconcat(u64 a, u64 b, u64 abl, u64 bbl) {")
(text "return cextract(abl + bbl - 1, 0, a << bbl + cextract(bbl - 1, 0, b));")))
(text "}")))
(add-cfunc 'cconcat)
(add-impl cconcat-impl)
(define (cconcat a b bl)
(cfunc 'cconcat (list a b bl)))
(define csign-extend-impl
(v-append
(nest 4 (v-append (text "u64 csign_extend(u64 b, u64 l, u64 bl) {")
(text "return cextract(l - 1, 0, b & ((b & (1 << (bl - 1))) ? (-1 << bl) : 0));")))
(text "}")))
(add-cfunc 'csign_extend)
(add-impl csign-extend-impl)
(define (csign-extend b l bl)
(cfunc 'csign_extend (list b l bl)))
(define czero-extend-impl
(v-append
(nest 4 (v-append (text "u64 czero_extend(u64 b, u64 l, u64 bl) {")
(text "return cextract(l - 1, 0, b);")))
(text "}")))
(add-cfunc 'czero_extend)
(add-impl czero-extend-impl)
(define (czero-extend b l bl)
(cfunc 'czero_extend (list b l bl)))
; TODO is this correct?
(define cextract-impl
(v-append
; TODO should I remove bl from this one?
(nest 4 (v-append (text "u64 cextract(u64 e, u64 s, u64 b) {")
(text "return (b << (63 - e)) >> (63 - e + s);")))
(text "}")))
(add-cfunc 'cextract)
(add-impl cextract-impl)
(define (cextract e s b)
(cfunc 'cextract (list e s b)))
#|
(define tgt-insn-impl
(v-append
(text "// TODO Implement this function in aux.h")
(text "// struct tgt_insn make_tgt_insn(...) {...}")))
(add-impl tgt-insn-impl)|#
(define tgt_insn
(lambda args
(cfunc 'make_tgt_insn args)))
(define (add-user-defined-func name)
(define impl
(v-append
(text "// TODO Implement this function in aux.h")
(text (~a "// u64 " name "(struct src_instr *si) {...}"))))
(add-cfunc name)
(add-impl impl))
(add-user-defined-func 'src_insn_op)
; TODO include the (mutable) target instruction here too
(define (emit x)
(cfunc 'emit (list x)))
(define (has-func? name)
(member name all-cfuncs))
(define (src-sym->cparam-helper sym si parameters)
(define param (first parameters))
(define candidate ((parameter-get param) si))
(debugln (~a "Candidate: " candidate))
(if (unsat? (verify (assert (bveq candidate sym))))
(let ([fname (string->symbol (~a "src_insn_" (parameter-name param)))])
(cfunc fname (list input-src-instr)))
(cond
[(empty? (rest parameters))
(debugln (~a "Not a sym value: " sym "\n for instruction " si))
#f]
[else (src-sym->cparam-helper sym si (rest parameters))])))
(define (src-sym->cparam sym si mch-src-instr)
(debugln (~a "Src symbolic value: " sym))
(debugln (~a "Src instr: " si))
(src-sym->cparam-helper sym si (instruction-params mch-src-instr)))
; TODO NEXT figure out how to get mch-src-instr here
(define (value->cparam value si mch-src-instr)
(debugln value)
(match* (value)
; TODO do I need an LL somewhere?
; can I just do bitvector->natural instead?
; and then put an "LL" in front of it when converting to text or smth
[((bv x _)) (cextract (sub1 (bv-size value)) 0 x)]
[((expression (== bvadd) a b)) (cadd (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvmul) a b)) (cmul (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvshl) a b)) (cshl (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvshl) a b)) (cshl (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvashr) a b)) (cashr (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvlshr) a b)) (clshr (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvor) a b)) (cor (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvxor) a b)) (cxor (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvand) a b)) (cand (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size a))]
[((expression (== bvneg) a)) (cneg (value->cparam a si mch-src-instr) (bv-size a))]
[((expression (== concat) a b)) (cconcat (value->cparam a si mch-src-instr) (value->cparam b si mch-src-instr) (bv-size b))]
[((expression (== extract) s e v)) (cextract s e (value->cparam v si mch-src-instr))]
[((expression (== zero-extend) a (bitvector b)))
(czero-extend (value->cparam a si mch-src-instr) b (bv-size a))]
[((expression (== sign-extend) a (bitvector b)))
(csign-extend (value->cparam a si mch-src-instr) b (bv-size a))]
; TODO other bvops?
; bveq
[((expression (== bveq) a b))
(ceq (value->cparam a si mch-src-instr)
(value->cparam b si mch-src-instr))]
; ite
[((expression (== ite) a b c))
(define src-sym (src-sym->cparam value si mch-src-instr))
(if src-sym
src-sym
(cite (value->cparam a si mch-src-instr)
(value->cparam b si mch-src-instr)
(value->cparam c si mch-src-instr)))]
; TODO should error when this returns #f or smth(?)
[(_)
(define src-sym (src-sym->cparam value si mch-src-instr))
(when (not src-sym)
(displayln (~a "Failed on sym value: " src-sym "\n for instruction " si)))
src-sym]))
(define (tgt-instr->cfunc si ti mch-src-instr tgt-instr-getters)
(let ([val-func (lambda (f) (value->cparam (f ti) si mch-src-instr))])
(apply tgt_insn (map val-func tgt-instr-getters))))
; More precisely, this is a list of cfuncs
(define (tgt-prog->cfunc si tgt-prog mch-src-instr target-machine)
(map (lambda (ti)
(let ([tgt-instr-getters (instr-getters target-machine ti)])
(tgt-instr->cfunc si ti mch-src-instr tgt-instr-getters)))
tgt-prog))
(define (op->text op)
(text
(~a
(cond
[(bv? op) (bitvector->natural op)]
[(symbol? op) op]
[else (error "op->text: op should be symbol or bitvector")]))))
(define (tgt-prog->text src-instr cfunc-tgt-prog mch-src-instr source)
(let ([body
(v-concat
(for/list ([cfunc-tgt-instr cfunc-tgt-prog])
(h-append (cparam->text (emit cfunc-tgt-instr))
(text ";"))))])
(v-append
(text (~a "// Instruction " (instruction-name mch-src-instr)))
(nest 4 (v-append
(h-append (text "case") space
; TODO assume that this is an ams/machine function
(op->text (mch-instr->distinct-op source mch-src-instr))
colon)
body
(text "break;"))))))
(define si-type "src_insn")
; TODO also include the target program as pointer in params
(define emit-insn-header
(nest 4 (v-append (text (~a "int emit_insn(" si-type " *si) {"))
; TODO make user provide "op" function
(text "switch (src_insn_op(si)) {"))))
(define emit-insn-tail
(v-append (indent 4 (text "}"))
(text "}")))
(define (helper-impl-text)
(v-concat (apply-infix line helper-impls)))
(define guard+comments
(v-append (text "#pragma once")
(text (~a "/* JIT compiler"))
(text " */")))
; TODO fill this out
(define includes
(v-append
(text "#include <stdio.h>")
(text "#include <string.h>")
(text "#include <stdbool.h>")
(text "#include <stdlib.h>")
(text "#include <stdarg.h>")
(text "#include <stdint.h>")
(text "#include <stddef.h>")
(text "#include \"aux.h\"")
(text "typedef unsigned long long u64;")
(text "typedef long long s64;")))
(define struct-defs
(v-append
(text "// TODO Define this struct in aux.h")
(text "// struct src_insn {...};")
(text "")
(text "// TODO (Optionally) Define this struct in aux.h")
(text "// struct tgt_insn {...};")))
(define cfile-header
(thunk
(v-append
guard+comments
empty
includes
empty
struct-defs
empty
(helper-impl-text)
empty
emit-insn-header
empty)))
(define cfile-tail
emit-insn-tail)
; NOTE: Assuming the compiler has already been synthesized
(define (create-cfile stp-file #:cache-dir [cache-dir "cchh"])
(let ([proglen (read-from-dir (stp-file->dir stp-file #f #:cache-dir cache-dir) "proglen.cch")])
(cond
[proglen
(define output-file (~a (stp-file->dir stp-file #f #:cache-dir cache-dir) "/compiler.h"))
(define stp ((dynamic-require stp-file 'make-stp)))
(define source (src/tgt-source stp))
(define target (src/tgt-target stp))
(define source-instrs (machine-instrs source))
(define bodies
(map
(lambda (src-instr)
(compute-body stp-file stp src-instr #:cache-dir cache-dir))
source-instrs))
(define output-port (start-cfile output-file))
(for ([body bodies])
(update-cfile body output-port))
(end-cfile output-port)]
[else
(displayln "C file not made because synthesis failed")])))
(define (start-cfile output-file)
(let ([port (open-output-file output-file #:exists 'replace)])
(pretty-print (cfile-header) port)
(close-output-port port)
(open-output-file output-file #:exists 'append)))
(define (compute-body stp-file src/tgt-pair src-instr #:cache-dir cache-dir)
(let* ([source (src/tgt-source src/tgt-pair)]
[target (src/tgt-target src/tgt-pair)]
[canon-src-instr (make-canon-instr source src-instr)]
[proglen (read-from-dir (stp-file->dir stp-file #f #:cache-dir cache-dir) "proglen.cch")]
[dir (~a (stp-file->dir stp-file #f #:cache-dir cache-dir) "/" (instruction-name src-instr))]
[tgt-prog (read-from-dir dir (~a proglen ".cch"))]
[body (tgt-prog->text canon-src-instr tgt-prog src-instr source)])
body))
(define (update-cfile body output-port)
(pretty-print
(h-append (indent 8 body) line)
output-port)
(flush-output output-port))
(define (end-cfile output-port)
(pretty-print cfile-tail output-port)
(close-output-port output-port))
| false |
d5965bb7022e18ea9de6655fdd3b05d17602e200 | d6b905b841a3c812ff1805879f681111f164e87c | /zenspider/ch07/ch07.rkt | e4524906d98bf73f39059fa60b6c6a53a8b7d5ef | [
"MIT"
]
| permissive | SeaRbSg/realm_of_racket | 40398e89ab2d39b7499bb97ee2a6b07bdb79c586 | b4383c6cab68b4cea04f514267c58397e8cc69d0 | refs/heads/master | 2021-03-12T22:50:14.935166 | 2017-11-30T23:40:10 | 2017-11-30T23:51:11 | 12,911,347 | 1 | 2 | null | null | null | null | UTF-8 | Racket | false | false | 3,110 | rkt | ch07.rkt | #lang racket
(require rackunit)
(require (file "../extras.rkt"))
;; 7.1
(check-output-equal? add1
"#<procedure:add1>")
(define (my-map f xs)
(cond [(empty? xs) empty]
[else (cons (f (first xs))
(my-map f (rest xs)))]))
(check-equal? (my-map add1 '(1 2 3 4))
'(2 3 4 5))
;; (define (rot goos)
;; (my-map decay goos))
;; 7.2
;; (define (rot goos)
;; (my-map (lambda (f) (goo (goo-loc f) (sub1 (goo-expire f)))) goos))
(define (sub2 n)
(+ n 2))
;; same as: (lambda (n) (- n 2))
(check-equal? ((lambda (n) (- n 2)) 5)
3)
;; 7.3
(define (my-filter pred lst)
(cond [(empty? lst) empty]
[(pred (first lst)) (cons (first lst) (my-filter (rest lst)))]
[else (my-filter (rest lst))]))
;; (define (renew goos)
;; (my-filter (lambda (f) (not (rotten? f))) goos))
(define (my-ormap pred lst)
(cond [(empty? lst) false]
[else (or (pred (first lst))
(my-ormap pred (rest lst)))]))
(define (my-andmap pred lst)
(cond [(empty? lst) true]
[else (and (pred (first lst))
(my-andmap pred (rest lst)))]))
(check-true (my-andmap number? empty))
(check-false (my-ormap number? empty))
(check-false (my-andmap number? '(1 2 3 "a")))
(check-true (my-ormap number? '(1 2 3 "a")))
;; (define (can-eat sn goos)
;; (define head (snake-head sn))
;; (my-ormap (lambda (g) (and (close? head g) g)) goos))
(define (my-foldr f base lst)
(cond [(empty? lst) base]
[else (f (first lst) (my-foldr f base (rest lst)))]))
(check-equal? (my-foldr + 0 '(1 2 3))
6)
;; (my-foldr beside empty-image (list <images...>))
;; (define (img-list+scene posns img scene)
;; (my-foldr (lambda (p s) (img+scene p img s)) scene posns))
;; 7.4
(define (my-foldl f base lst)
(cond [(empty? lst) base]
[else (my-foldl f (f (first lst) base) (rest lst))]))
(check-equal? (my-foldl cons empty '(a b c))
'(c b a))
(check-equal? (my-foldr cons empty '(a b c))
'(a b c))
(define (my-build-list n f)
(define (builder k)
(cond [(= n k) empty]
[else (cons (f k) (builder (add1 k)))]))
(builder 0))
(check-equal? (my-build-list 5 add1)
'(1 2 3 4 5))
(check-equal? (my-build-list 10 (lambda (n) (* n 2)))
'(0 2 4 6 8 10 12 14 16 18))
;; 7.5
(define (d/dx f)
(define ∂ (/ 1 100000))
(lambda (x)
(/ (- (f (+ x ∂)) (f (- x ∂))) 2 ∂)))
(define two (d/dx (lambda (x) (* 2 x))))
(check-equal? (two 17)
2)
(check-equal? (map two '(2 -1 0 1 24))
'(2 2 2 2 2))
(define newcos (d/dx sin))
(check-= (newcos 0)
0.9999
0.001)
(define answers (map newcos (list (/ pi 2) pi)))
(check-= (first answers) 0.0 0.001)
(check-= (last answers) -0.9999 0.001)
;; 7.6
(define (sum lon) (apply + lon))
(check-equal? (sum '(1 2 3 4 5 6))
21)
(define (highest lon) (apply max lon))
(check-equal? (highest '(58 64 77 77 22 94 93 78))
94)
;; (define (row lop) (apply (beside (map frame lop))))
| false |
a968c3a5b28c3ab149a0c253538e97200c6729fa | 82c76c05fc8ca096f2744a7423d411561b25d9bd | /typed-racket-test/fail/unit-ctc-init-depends.rkt | 07e166201f1400c2a096bec40bff9b52b0f3739c | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/typed-racket | 2cde60da289399d74e945b8f86fbda662520e1ef | f3e42b3aba6ef84b01fc25d0a9ef48cd9d16a554 | refs/heads/master | 2023-09-01T23:26:03.765739 | 2023-08-09T01:22:36 | 2023-08-09T01:22:36 | 27,412,259 | 571 | 131 | NOASSERTION | 2023-08-09T01:22:41 | 2014-12-02T03:00:29 | Racket | UTF-8 | Racket | false | false | 476 | rkt | unit-ctc-init-depends.rkt | #;
(exn-pred #rx"x@: broke its own contract;\n contract does not list initialization dependency x\\^")
#lang racket
(module untyped racket
(provide x^ x@)
(define-signature x^ (x))
(define x@
(unit
(import x^)
(export)
(init-depend x^)
x)))
(module typed typed/racket
(require/typed (submod ".." untyped)
[#:signature x^ ([x : Integer])]
[x@ (Unit (import x^)
(export)
Integer)]))
(require 'typed)
| false |
b852e537c209c34c20360572f4f1529b8682cf85 | df0ba5a0dea3929f29358805fe8dcf4f97d89969 | /exercises/computer-science-3/exercises/03.higher-order-functions/solutions/06-combine-numbers.rkt | 46d6a11202d043ec0d96257b74cfcba533dd9fd5 | [
"MIT"
]
| permissive | triffon/fp-2019-20 | 1c397e4f0bf521bf5397f465bd1cc532011e8cf1 | a74dcde683538be031186cf18367993e70dc1a1c | refs/heads/master | 2021-12-15T00:32:28.583751 | 2021-12-03T13:57:04 | 2021-12-03T13:57:04 | 210,043,805 | 14 | 31 | MIT | 2019-12-23T23:39:09 | 2019-09-21T19:41:41 | Racket | UTF-8 | Racket | false | false | 2,781 | rkt | 06-combine-numbers.rkt | #lang racket
(require rackunit)
(require rackunit/text-ui)
; Функцията, която ще напишете, очаква за вход две цели положителни числа, кръстени за по-удобно "first" и "second", и бинарна функция.
; Ако f1,f2,f3,...,fk и s1,s2,s3,...,sl са цифрите на съответните числа, а g е нашата бинарна функция, търсим резултатът от g(f1,s1) + g(f2,s2) + g(f3,s3) + ...
; Функцията да терминира при достигане края на едно от числата.
(define (combine-numbers first second g)
; тази и долната функция правят окей неща, но може да стане и по-просто
; няма нужда да започваме от първата цифра и на двете числа и да продължаваме нататък
; спокойно може да започнем отзад напред
; как взимаме последната цифра? (remainder x 10)
; как взимаме всички без последната? (quotient x 10)
(define (first-digit number)
(if (= (quotient number 10) 0)
number
(first-digit (quotient number 10))))
(define (remove-first-digit number)
(define (remove number power)
(if (= (quotient number 10) 0)
0
(+ (* (remainder number 10) power) (remove (quotient number 10) (* power 10)))))
(remove number 1)
)
(if (or (= first 0) (= second 0))
0
(+ (g (first-digit first) (first-digit second)) (combine-numbers (remove-first-digit first) (remove-first-digit second) g)))
)
; Бонус занимавка: Да параметризираме и операцията, с която комбинираме резултатите от g(fk,sl).
; В горната функция сме я забили на "+".
(define tests
(test-suite "Combine numbers tests"
; Защото (remainder k k) = 0
(check-equal? (combine-numbers 123 123 remainder) 0)
; Защото (4 * 9) + (2 * 8) = 52
(check-equal? (combine-numbers 421384 98 *) 52)
; Защото (1 < 7) -> 1, (2 = 2) -> 0, (5 > 3) -> 0, (9 = 9) -> 0, (3 < 7) -> 1
(check-equal? (combine-numbers 12593 72397 (lambda (x y) (if (< x y) 1 0))) 2)
; Като горния тест, но с по-късо второ число.
(check-equal? (combine-numbers 2713 98 (lambda (x y) (if (< x y) 1 0))) 2)
; Като горния тест, но с по-късо първо число.
(check-equal? (combine-numbers 213 91423 (lambda (x y) (if (< x y) 1 0))) 2)
)
)
(run-tests tests 'verbose)
| false |
f28d3d178db0a26bd43a128005818c7b3d2f0aba | 2767601ac7d7cf999dfb407a5255c5d777b7b6d6 | /examples/mood-ring.rkt | 52fc632356c4487365b6d89e93eda553e00aa6ae | []
| no_license | manbaum/moby-scheme | 7fa8143f3749dc048762db549f1bcec76b4a8744 | 67fdf9299e9cf573834269fdcb3627d204e402ab | refs/heads/master | 2021-01-18T09:17:10.335355 | 2011-11-08T01:07:46 | 2011-11-08T01:07:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,173 | rkt | mood-ring.rkt | #lang planet dyoo/moby:3:9
(require (planet dyoo/moby:3:9/phone/tilt))
; The world is a color.
(define initial-world (make-color 0 0 0))
; tilt: world number number number -> world
; Tilting the phone adjusts the color.
(define (tilt w azimuth pitch roll)
(make-color (scale azimuth 360)
(scale (+ pitch 90) 180)
(scale (+ roll 90) 180)))
; scale-azimuth: number -> number
; Take a number going from 0-360 and scale it to a number between 0-255
(define (scale n domain-bound)
(inexact->exact (floor (* (/ n domain-bound) 255))))
; User interface.
(define view (list (js-div '((id "background")))))
(define (draw-html w) view)
(define (draw-css w)
(list (list "background"
(list "background-color"
(format "rgb(~a, ~a, ~a)"
(color-red w)
(color-green w)
(color-blue w)))
(list "width" "300")
(list "height" "300"))))
(big-bang initial-world
(on-tilt tilt)
(to-draw-page draw-html draw-css))
| false |
9ce125071d5b01382cc445c4097bb445aabb6f24 | d9276fbd73cdec7a5a4920e46af2914f8ec3feb1 | /data/scheme/type-rep.rkt | d8f576673691d3b2ebbcf6b5601e05b556f30e03 | []
| no_license | CameronBoudreau/programming-language-classifier | 5c7ab7d709b270f75269aed1fa187e389151c4f7 | 8f64f02258cbab9e83ced445cef8c1ef7e5c0982 | refs/heads/master | 2022-10-20T23:36:47.918534 | 2016-05-02T01:08:13 | 2016-05-02T01:08:13 | 57,309,188 | 1 | 1 | null | 2022-10-15T03:50:41 | 2016-04-28T14:42:50 | C | UTF-8 | Racket | false | false | 38,318 | rkt | type-rep.rkt | #lang racket/base
;; This module provides type representations and utility functions
;; and pattern matchers on types
(require "../utils/utils.rkt")
;; TODO use contract-req
(require (utils tc-utils)
"rep-utils.rkt" "object-rep.rkt" "filter-rep.rkt" "free-variance.rkt"
racket/match racket/list
racket/contract
racket/lazy-require
racket/promise
(for-syntax racket/base syntax/parse))
(provide Mu-name:
Poly-names: Poly-fresh:
PolyDots-names:
PolyRow-names: PolyRow-fresh:
Type-seq
Mu-unsafe: Poly-unsafe:
PolyDots-unsafe:
Mu? Poly? PolyDots? PolyRow?
Filter? Object?
Type/c Type/c?
Values/c SomeValues/c
Bottom?
Poly-n
PolyDots-n
Class? Row? Row:
free-vars*
type-equal?
remove-dups
sub-t sub-f sub-o sub-pe
Name/simple: Name/struct:
(rename-out [Class:* Class:]
[Class* make-Class]
[Row* make-Row]
[Mu:* Mu:]
[Poly:* Poly:]
[PolyDots:* PolyDots:]
[PolyRow:* PolyRow:]
[Mu* make-Mu]
[Poly* make-Poly]
[PolyDots* make-PolyDots]
[PolyRow* make-PolyRow]
[Mu-body* Mu-body]
[Poly-body* Poly-body]
[PolyDots-body* PolyDots-body]
[PolyRow-body* PolyRow-body]))
;; Ugly hack - should use units
(lazy-require
("../types/union.rkt" (Un))
("../types/resolve.rkt" (resolve-app)))
(define name-table (make-weak-hasheq))
(define Type/c?
(λ (e)
(and (Type? e)
(not (arr? e))
(not (fld? e))
(not (Values? e))
(not (ValuesDots? e))
(not (AnyValues? e))
(not (Result? e))
(not (Signature? e)))))
;; (or/c Type/c Values? Results?)
;; Anything that can be treated as a Values by sufficient expansion
(define Values/c?
(λ (e)
(and (Type? e)
(not (arr? e))
(not (fld? e))
(not (ValuesDots? e))
(not (AnyValues? e))
(not (Signature? e)))))
(define Type/c (flat-named-contract 'Type Type/c?))
(define Values/c (flat-named-contract 'Values Values/c?))
(define Bottom?
(match-lambda
[(Union: (list)) #t]
[else #f]))
;; Name = Symbol
;; Type is defined in rep-utils.rkt
;; this is ONLY used when a type error ocurrs
(def-type Error () [#:frees #f] [#:fold-rhs #:base])
;; de Bruijn indexes - should never appear outside of this file
;; bound type variables
;; i is an nat
(def-type B ([i natural-number/c]) [#:frees #f] [#:fold-rhs #:base])
;; free type variables
;; n is a Name
(def-type F ([n symbol?]) [#:frees (single-free-var n) empty-free-vars]
[#:fold-rhs #:base])
;; Name, an indirection of a type through the environment
;;
;; interp.
;; A type name, potentially recursive or mutually recursive or pointing
;; to a type for a struct type
;; id is the name stored in the environment
;; args is the number of arguments expected by this Name type
;; struct? indicates if this maps to a struct type
(def-type Name ([id identifier?]
[args exact-nonnegative-integer?]
[struct? boolean?])
[#:intern (hash-id id)] [#:frees #f] [#:fold-rhs #:base])
;; rator is a type
;; rands is a list of types
;; stx is the syntax of the pair of parens
(def-type App ([rator Type/c] [rands (listof Type/c)] [stx (or/c #f syntax?)])
[#:intern (cons (Rep-seq rator) (map Rep-seq rands))]
[#:frees (λ (f)
(match rator
((Name: n _ _)
(instantiate-frees n (map f rands)))
(else (f (resolve-app rator rands stx)))))]
[#:fold-rhs (*App (type-rec-id rator)
(map type-rec-id rands)
stx)])
;; left and right are Types
(def-type Pair ([left Type/c] [right Type/c]) [#:key 'pair])
;; dotted list -- after expansion, becomes normal Pair-based list type
(def-type ListDots ([dty Type/c] [dbound (or/c symbol? natural-number/c)])
[#:frees (if (symbol? dbound)
(free-vars-remove (free-vars* dty) dbound)
(free-vars* dty))
(if (symbol? dbound)
(combine-frees (list (single-free-var dbound) (free-idxs* dty)))
(free-idxs* dty))]
[#:fold-rhs (*ListDots (type-rec-id dty) dbound)])
;; *mutable* pairs - distinct from regular pairs
;; left and right are Types
(def-type MPair ([left Type/c] [right Type/c])
[#:frees (λ (f) (make-invariant (combine-frees (list (f left) (f right)))))]
[#:key 'mpair])
;; elem is a Type
(def-type Vector ([elem Type/c])
[#:frees (λ (f) (make-invariant (f elem)))]
[#:key 'vector])
;; elems are all Types
(def-type HeterogeneousVector ([elems (listof Type/c)])
[#:intern (map Rep-seq elems)]
[#:frees (λ (f) (make-invariant (combine-frees (map f elems))))]
[#:key 'vector]
[#:fold-rhs (*HeterogeneousVector (map type-rec-id elems))])
;; elem is a Type
(def-type Box ([elem Type/c])
[#:frees (λ (f) (make-invariant (f elem)))]
[#:key 'box])
;; elem is a Type
(def-type Channel ([elem Type/c])
[#:frees (λ (f) (make-invariant (f elem)))]
[#:key 'channel])
;; elem is a Type
(def-type Async-Channel ([elem Type/c])
[#:frees (λ (f) (make-invariant (f elem)))]
[#:key 'async-channel])
;; elem is a Type
(def-type ThreadCell ([elem Type/c])
[#:frees (λ (f) (make-invariant (f elem)))]
[#:key 'thread-cell])
;; elem is a Type
(def-type Promise ([elem Type/c])
[#:key 'promise])
;; elem is a Type
(def-type Ephemeron ([elem Type/c])
[#:key 'ephemeron])
;; elem is a Type
(def-type Weak-Box ([elem Type/c])
[#:key 'weak-box])
;; elem is a Type
(def-type CustodianBox ([elem Type/c])
[#:key 'custodian-box])
;; elem is a Type
(def-type Set ([elem Type/c])
[#:key 'set])
;; result is a Type
(def-type Evt ([result Type/c])
[#:key #f])
;; name is a Symbol (not a Name)
;; contract is used when generating contracts from types
;; predicate is used to check (at compile-time) whether a value belongs
;; to that base type. This is used to check for subtyping between value
;; types and base types.
;; numeric determines if the type is a numeric type
(def-type Base ([name symbol?] [contract syntax?] [predicate procedure?] [numeric? boolean?])
[#:frees #f] [#:fold-rhs #:base] [#:intern name]
[#:key (if numeric?
'number
(case name
[(Boolean) 'boolean]
[(String) 'string]
[(Symbol) 'symbol]
[(Keyword) 'keyword]
[else #f]))])
(def-type Mu ([body Type/c]) #:no-provide [#:frees (λ (f) (f body))]
[#:fold-rhs (*Mu (type-rec-id body))]
[#:key (Type-key body)])
;; n is how many variables are bound here
;; body is a type
(def-type Poly (n body) #:no-provide
[#:contract (->i ([n natural-number/c]
[body Type/c])
(#:syntax [stx (or/c #f syntax?)])
[result Poly?])]
[#:frees (λ (f) (f body))]
[#:fold-rhs (*Poly n (type-rec-id body))]
[#:key (Type-key body)])
;; n is how many variables are bound here
;; there are n-1 'normal' vars and 1 ... var
(def-type PolyDots (n body) #:no-provide
[#:contract (->i ([n natural-number/c]
[body Type/c])
(#:syntax [stx (or/c #f syntax?)])
[result PolyDots?])]
[#:key (Type-key body)]
[#:frees (λ (f) (f body))]
[#:fold-rhs (*PolyDots n (type-rec-id body))])
;; interp. A row polymorphic function type
;; constraints are row absence constraints, represented
;; as a set for each of init, field, methods
(def-type PolyRow (constraints body) #:no-provide
[#:contract (->i ([constraints (list/c list? list? list? list?)]
[body Type/c])
(#:syntax [stx (or/c #f syntax?)])
[result PolyRow?])]
[#:frees (λ (f) (f body))]
[#:fold-rhs (*PolyRow constraints
(type-rec-id body))]
[#:key (Type-key body)])
;; pred : identifier
(def-type Opaque ([pred identifier?])
[#:intern (hash-id pred)] [#:frees #f] [#:fold-rhs #:base] [#:key pred])
;; kw : keyword?
;; ty : Type
;; required? : Boolean
(def-type Keyword ([kw keyword?] [ty Type/c] [required? boolean?])
[#:frees (λ (f) (f ty))]
[#:fold-rhs (*Keyword kw (type-rec-id ty) required?)])
(def-type Result ([t Type/c] [f FilterSet?] [o Object?])
[#:frees (λ (frees) (combine-frees (map frees (list t f o))))]
[#:fold-rhs (*Result (type-rec-id t) (filter-rec-id f) (object-rec-id o))])
(def-type Values ([rs (listof Result?)])
[#:intern (map Rep-seq rs)]
[#:frees (λ (f) (combine-frees (map f rs)))]
[#:fold-rhs (*Values (map type-rec-id rs))])
(def-type AnyValues ([f Filter/c])
[#:fold-rhs #:base])
(def-type ValuesDots ([rs (listof Result?)] [dty Type/c] [dbound (or/c symbol? natural-number/c)])
[#:intern (list (map Rep-seq rs) (Rep-seq dty) dbound)]
[#:frees (if (symbol? dbound)
(free-vars-remove (combine-frees (map free-vars* (cons dty rs))) dbound)
(combine-frees (map free-vars* (cons dty rs))))
(if (symbol? dbound)
(combine-frees (cons (single-free-var dbound)
(map free-idxs* (cons dty rs))))
(combine-frees (map free-idxs* (cons dty rs))))]
[#:fold-rhs (*ValuesDots (map type-rec-id rs) (type-rec-id dty) dbound)])
(define SomeValues/c (or/c Values? AnyValues? ValuesDots?))
;; arr is NOT a Type
(def-type arr ([dom (listof Type/c)]
[rng SomeValues/c]
[rest (or/c #f Type/c)]
[drest (or/c #f (cons/c Type/c (or/c natural-number/c symbol?)))]
[kws (listof Keyword?)])
[#:intern (list (map Rep-seq dom) (Rep-seq rng) (and rest (Rep-seq rest))
(and drest (cons (Rep-seq (car drest)) (cdr drest)))
(map Rep-seq kws))]
[#:frees (combine-frees
(append (map (compose flip-variances free-vars*)
(append (if rest (list rest) null)
(map Keyword-ty kws)
dom))
(match drest
[(cons t (? symbol? bnd))
(list (free-vars-remove (flip-variances (free-vars* t)) bnd))]
[(cons t _)
(list (flip-variances (free-vars* t)))]
[_ null])
(list (free-vars* rng))))
(combine-frees
(append (map (compose flip-variances free-idxs*)
(append (if rest (list rest) null)
(map Keyword-ty kws)
dom))
(match drest
[(cons t (? symbol? bnd))
(list (single-free-var bnd Contravariant)
(flip-variances (free-idxs* t)))]
[(cons t _)
(list (flip-variances (free-idxs* t)))]
[_ null])
(list (free-idxs* rng))))]
[#:fold-rhs (*arr (map type-rec-id dom)
(type-rec-id rng)
(and rest (type-rec-id rest))
(and drest (cons (type-rec-id (car drest)) (cdr drest)))
(map type-rec-id kws))])
;; arities : Listof[arr]
(def-type Function ([arities (listof arr?)])
[#:intern (map Rep-seq arities)]
[#:key 'procedure]
[#:frees (λ (f) (combine-frees (map f arities)))]
[#:fold-rhs (*Function (map type-rec-id arities))])
(def-type fld ([t Type/c] [acc identifier?] [mutable? boolean?])
[#:frees (λ (f) (if mutable? (make-invariant (f t)) (f t)))]
[#:fold-rhs (*fld (type-rec-id t) acc mutable?)]
[#:intern (list (Rep-seq t) (hash-id acc) mutable?)])
;; name : identifier
;; parent : Struct
;; flds : Listof[fld]
;; proc : Function Type
;; poly? : is this type polymorphically variant
;; If not, then the predicate is enough for higher order checks
;; pred-id : identifier for the predicate of the struct
;; acc-ids : names of the accessors
;; maker-id : name of the constructor
(def-type Struct ([name identifier?]
[parent (or/c #f Struct?)]
[flds (listof fld?)]
[proc (or/c #f Function?)]
[poly? boolean?]
[pred-id identifier?])
[#:intern (list (hash-id name)
(hash-id pred-id)
(and parent (Rep-seq parent))
(map Rep-seq flds)
(and proc (Rep-seq proc)))]
[#:frees (λ (f) (combine-frees (map f (append (if proc (list proc) null)
(if parent (list parent) null)
flds))))]
[#:fold-rhs (*Struct name
(and parent (type-rec-id parent))
(map type-rec-id flds)
(and proc (type-rec-id proc))
poly?
pred-id)]
;; This should eventually be based on understanding of struct properties.
[#:key '(struct procedure)])
;; Represents prefab structs
;; key : prefab key encoding mutability, auto-fields, etc.
;; flds : the types of all of the prefab fields
(def-type Prefab ([key prefab-key?]
[flds (listof Type/c)])
[#:frees (λ (f) (combine-frees (map f flds)))]
[#:fold-rhs (*Prefab key (map type-rec-id flds))]
[#:key 'prefab])
;; A structure type descriptor
(def-type StructTypeTop () [#:fold-rhs #:base] [#:key 'struct-type])
(def-type StructType ([s (or/c F? B? Struct? Prefab?)]) [#:key 'struct-type])
;; the supertype of all of these values
(def-type BoxTop () [#:fold-rhs #:base] [#:key 'box])
(def-type Weak-BoxTop () [#:fold-rhs #:base] [#:key 'weak-box])
(def-type ChannelTop () [#:fold-rhs #:base] [#:key 'channel])
(def-type Async-ChannelTop () [#:fold-rhs #:base] [#:key 'async-channel])
(def-type VectorTop () [#:fold-rhs #:base] [#:key 'vector])
(def-type HashtableTop () [#:fold-rhs #:base] [#:key 'hash])
(def-type MPairTop () [#:fold-rhs #:base] [#:key 'mpair])
(def-type StructTop ([name Struct?]) [#:key 'struct])
(def-type ThreadCellTop () [#:fold-rhs #:base] [#:key 'thread-cell])
(def-type Prompt-TagTop () [#:fold-rhs #:base] [#:key 'prompt-tag])
(def-type Continuation-Mark-KeyTop ()
[#:fold-rhs #:base] [#:key 'continuation-mark-key])
;; v : Racket Value
(def-type Value (v) [#:frees #f] [#:fold-rhs #:base]
[#:key (cond [(or (eq? v 0) (eq? v 1)) 'number]
;; other numbers don't work with the optimizations in subtype.rkt
;; which assume that unions of numbers are subtyped in simple ways
[(boolean? v) 'boolean]
[(null? v) 'null]
[else #f])])
;; elems : Listof[Type]
(def-type Union ([elems (and/c (listof Type/c)
(lambda (es)
(or (null? es)
(let-values ([(sorted? k)
(for/fold ([sorted? #t]
[last (car es)])
([e (cdr es)])
(values
(and sorted? (type<? last e))
e))])
sorted?))))])
[#:intern (map Rep-seq elems)]
[#:frees (λ (f) (combine-frees (map f elems)))]
[#:fold-rhs (apply Un (map type-rec-id elems))]
[#:key
(let ()
(define d
(let loop ([ts elems] [res null])
(cond [(null? ts) res]
[else
(define k (Type-key (car ts)))
(cond [(not k) (list #f)]
[(pair? k) (loop (cdr ts) (append k res))]
[else (loop (cdr ts) (cons k res))])])))
(define d* (remove-duplicates d))
(if (and (pair? d*) (null? (cdr d*))) (car d*) d*))])
(def-type Univ () [#:frees #f] [#:fold-rhs #:base])
;; in : Type
;; out : Type
(def-type Param ([in Type/c] [out Type/c])
[#:key 'procedure]
[#:frees (λ (f) (combine-frees (list (f out) (flip-variances (f in)))))])
;; key : Type
;; value : Type
(def-type Hashtable ([key Type/c] [value Type/c]) [#:key 'hash]
[#:frees (λ (f) (combine-frees (list (make-invariant (f key)) (make-invariant (f value)))))])
(def-type Refinement ([parent Type/c] [pred identifier?])
[#:key (Type-key parent)]
[#:intern (list (Rep-seq parent) (hash-id pred))]
[#:fold-rhs (*Refinement (type-rec-id parent) pred)]
[#:frees (λ (f) (f parent))])
;; Syntax
;; t : Type
;; t is the type of the result of syntax-e, not the result of syntax->datum
(def-type Syntax ([t Type/c]) [#:key 'syntax])
;; A Row used in type instantiation
;; For now, this should not appear in user code. It's used
;; internally to perform row instantiations and to represent
;; class types.
;;
;; invariant: all clauses are sorted by the key name
(def-type Row ([inits (listof (list/c symbol? Type/c boolean?))]
[fields (listof (list/c symbol? Type/c))]
[methods (listof (list/c symbol? Type/c))]
[augments (listof (list/c symbol? Type/c))]
[init-rest (or/c Type/c #f)])
#:no-provide
[#:frees (λ (f) (combine-frees
(map f (append (map cadr inits)
(map cadr fields)
(map cadr methods)
(map cadr augments)
(if init-rest (list init-rest) null)))))]
[#:fold-rhs (match (list inits fields methods augments init-rest)
[(list
(list (list init-names init-tys reqd) ___)
(list (list fname fty) ___)
(list (list mname mty) ___)
(list (list aname aty) ___)
init-rest)
(*Row
(map list
init-names
(map type-rec-id init-tys)
reqd)
(map list fname (map type-rec-id fty))
(map list mname (map type-rec-id mty))
(map list aname (map type-rec-id aty))
(if init-rest (type-rec-id init-rest) #f))])])
;; Supertype of all Class types, cannot instantiate
;; or subclass these
(def-type ClassTop () [#:fold-rhs #:base] [#:key 'class])
;; row-ext : Option<(U F B Row)>
;; row : Row
;;
;; interp. The first field represents a row extension
;; The second field represents the concrete row
;; that the class starts with
;;
(def-type Class ([row-ext (or/c #f F? B? Row?)]
[row Row?])
#:no-provide
[#:frees (λ (f) (combine-frees
;; FIXME: is this correct?
`(,@(or (and (F? row-ext) (list (f row-ext)))
'())
,(f row))))]
[#:key 'class]
[#:fold-rhs (match (list row-ext row)
[(list row-ext row)
(*Class
(and row-ext (type-rec-id row-ext))
(type-rec-id row))])])
;; cls : Class
(def-type Instance ([cls Type/c]) [#:key 'instance])
;; interp:
;; name is the id of the signature
;; extends is the extended signature or #f
;; mapping maps variables in a signature to their types
;; This is not a type because signatures are not values
(def-type Signature ([name identifier?]
[extends (or/c identifier? #f)]
[mapping (listof (cons/c identifier? (or/c promise? Type/c)))])
[#:frees (lambda (f) null)]
[#:fold-rhs (*Signature name extends mapping)])
;; The supertype of all units, ie values recognized by the
;; predicate unit?
(def-type UnitTop () [#:fold-rhs #:base] [#:key 'unit])
;; interp: imports is the list of imported signatures
;; exports is the list of exported signatures
;; init-depends is the list of init-depend signatures
;; result is the type of the body of the unit
(def-type Unit ([imports (listof Signature?)]
[exports (listof Signature?)]
[init-depends (listof Signature?)]
[result SomeValues/c])
[#:frees (lambda (f) (f result))]
[#:fold-rhs (*Unit (map type-rec-id imports)
(map type-rec-id exports)
(map type-rec-id init-depends)
(type-rec-id result))])
;; sequences
;; includes lists, vectors, etc
;; tys : sequence produces this set of values at each step
(def-type Sequence ([tys (listof Type/c)])
[#:intern (map Rep-seq tys)]
[#:frees (λ (f) (combine-frees (map f tys)))]
[#:key #f] [#:fold-rhs (*Sequence (map type-rec-id tys))])
(def-type Future ([t Type/c]) [#:key 'future])
;; body: the type of the body
;; handler: the type of the prompt handler
;; prompts with this tag will return a union of `body`
;; and the codomains of `handler`
(def-type Prompt-Tagof ([body Type/c] [handler Type/c])
[#:frees (λ (f) (combine-frees (list (make-invariant (f body))
(make-invariant (f handler)))))]
[#:key 'prompt-tag])
;; value: the type of allowable values
(def-type Continuation-Mark-Keyof ([value Type/c])
[#:frees (λ (f) (make-invariant (f value)))]
[#:key 'continuation-mark-key])
;; Distinction
;; comes from define-new-subtype
;; nm: a symbol representing the name of the type
;; id: a symbol created with gensym
;; ty: a type for the representation, where this will be a subtype of ty
(def-type Distinction ([nm symbol?] [id symbol?] [ty Type/c])
[#:frees (λ (f) (f ty))]
[#:intern (list (Rep-seq ty) nm id)]
[#:fold-rhs (*Distinction nm id (type-rec-id ty))]
[#:key (Type-key ty)])
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; remove-dups: List[Type] -> List[Type]
;; removes duplicate types from a SORTED list
(define/cond-contract (remove-dups types)
((listof Rep?) . -> . (listof Rep?))
(cond [(null? types) types]
[(null? (cdr types)) types]
[(type-equal? (car types) (cadr types)) (remove-dups (cdr types))]
[else (cons (car types) (remove-dups (cdr types)))]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define ((sub-f st) e)
(filter-case (#:Type st
#:Filter (sub-f st)
#:PathElem (sub-pe st))
e))
(define ((sub-o st) e)
(object-case (#:Type st
#:Object (sub-o st)
#:PathElem (sub-pe st))
e))
(define ((sub-pe st) e)
(pathelem-case (#:Type st
#:PathElem (sub-pe st))
e))
(define ((sub-t st) e)
(type-case (#:Type st
#:Filter (sub-f st))
e))
;; abstract-many : Names Type -> Type
;; where n is the length of names
(define (abstract-many names ty)
;; mapping : dict[Type -> Natural]
(define (nameTo mapping type)
(let loop ([outer 0] [ty type])
(define (sb t) (loop outer t))
;; transform : Name (Integer -> a) a -> a
;; apply `mapping` to `name*`, returning `default` if it's not there
;; use `f` to wrap the result
;; note that this takes into account the value of `outer`
(define (transform name* f default)
(cond [(assq name* mapping)
=> (λ (pr)
(f (+ (cdr pr) outer)))]
[else default]))
(type-case
(#:Type sb #:Filter (sub-f sb) #:Object (sub-o sb))
ty
[#:F name* (transform name* *B ty)]
;; necessary to avoid infinite loops
[#:Union elems (*Union (remove-dups (sort (map sb elems) type<?)))]
;; functions
[#:arr dom rng rest drest kws
(*arr (map sb dom)
(sb rng)
(if rest (sb rest) #f)
(if drest
(cons (sb (car drest))
(let ([c (cdr drest)])
(transform c values c)))
#f)
(map sb kws))]
[#:ValuesDots rs dty dbound
(*ValuesDots (map sb rs)
(sb dty)
(transform dbound values dbound))]
[#:ListDots dty dbound
(*ListDots (sb dty)
(transform dbound values dbound))]
[#:Mu body (*Mu (loop (add1 outer) body))]
[#:PolyRow constraints body
(*PolyRow constraints (loop (+ 1 outer) body))]
[#:PolyDots n body
(*PolyDots n (loop (+ n outer) body))]
[#:Poly n body
(*Poly n (loop (+ n outer) body))])))
(define n (length names))
(define mapping (for/list ([nm (in-list names)]
[i (in-range n 0 -1)])
(cons nm (sub1 i))))
(nameTo mapping ty))
;; instantiate-many : List[Type] Type -> Type
;; where n is the length of types
;; all of the types MUST be Fs
(define (instantiate-many images ty)
;; mapping : dict[Natural -> Type]
(define (replace mapping type)
(let loop ([outer 0] [ty type])
;; transform : Integer (Name -> a) a -> a
;; apply `mapping` to `idx`, returning `default` if it's not there
;; use `f` to wrap the result
;; note that this takes into account the value of `outer`
(define (transform idx f default)
(cond [(assf (lambda (v) (eqv? (+ v outer) idx)) mapping)
=> (lambda (pr) (f (cdr pr)))]
[else default]))
(define (sb t) (loop outer t))
(define sf (sub-f sb))
(type-case
(#:Type sb #:Filter sf #:Object (sub-o sb))
ty
[#:B idx (transform idx values ty)]
;; necessary to avoid infinite loops
[#:Union elems (*Union (remove-dups (sort (map sb elems) type<?)))]
;; functions
[#:arr dom rng rest drest kws
(*arr (map sb dom)
(sb rng)
(if rest (sb rest) #f)
(if drest
(cons (sb (car drest))
(transform (cdr drest) F-n (cdr drest)))
#f)
(map sb kws))]
[#:ValuesDots rs dty dbound
(*ValuesDots (map sb rs)
(sb dty)
(transform dbound F-n dbound))]
[#:ListDots dty dbound
(*ListDots (sb dty)
(transform dbound F-n dbound))]
[#:Mu body (*Mu (loop (add1 outer) body))]
[#:PolyRow constraints body
(*PolyRow constraints (loop (+ 1 outer) body))]
[#:PolyDots n body
(*PolyDots n (loop (+ n outer) body))]
[#:Poly n body
(*Poly n (loop (+ n outer) body))])))
(define n (length images))
(define mapping (for/list ([img (in-list images)]
[i (in-range n 0 -1)])
(cons (sub1 i) img)))
(replace mapping ty))
(define (abstract name ty)
(abstract-many (list name) ty))
(define (instantiate type sc)
(instantiate-many (list type) sc))
;; the 'smart' constructor
(define (Mu* name body)
(let ([v (*Mu (abstract name body))])
(hash-set! name-table v name)
v))
;; the 'smart' destructor
(define (Mu-body* name t)
(match t
[(Mu: body)
(instantiate (*F name) body)]))
;; the 'smart' constructor
;;
;; Corresponds to closing a type in locally nameless representation
;; (turns free `names` into bound De Bruijn vars)
;; Also keeps track of the original name in a table to recover names
;; for debugging or to correlate with surface syntax
;;
;; Provide #:original-names if the names that you are closing off
;; are *different* from the names you want recorded in the table.
;;
;; list<symbol> type #:original-names list<symbol> -> type
;;
(define (Poly* names body #:original-names [orig names])
(if (null? names) body
(let ([v (*Poly (length names) (abstract-many names body))])
(hash-set! name-table v orig)
v)))
;; the 'smart' destructor
(define (Poly-body* names t)
(match t
[(Poly: n body)
(unless (= (length names) n)
(int-err "Wrong number of names: expected ~a got ~a" n (length names)))
(instantiate-many (map *F names) body)]))
;; the 'smart' constructor
(define (PolyDots* names body)
(if (null? names) body
(let ([v (*PolyDots (length names) (abstract-many names body))])
(hash-set! name-table v names)
v)))
;; the 'smart' destructor
(define (PolyDots-body* names t)
(match t
[(PolyDots: n body)
(unless (= (length names) n)
(int-err "Wrong number of names: expected ~a got ~a" n (length names)))
(instantiate-many (map *F names) body)]))
;; Constructor and destructor for row polymorphism
;;
;; Note that while `names` lets you specify multiple names, it's
;; expected that row polymorphic types only bind a single name at
;; a time. This may change in the future.
;;
(define (PolyRow* names constraints body #:original-names [orig names])
(let ([v (*PolyRow constraints (abstract-many names body))])
(hash-set! name-table v orig)
v))
(define (PolyRow-body* names t)
(match t
[(PolyRow: constraints body)
(instantiate-many (map *F names) body)]))
(print-struct #t)
(define-match-expander Mu-unsafe:
(lambda (stx)
(syntax-case stx ()
[(_ bp) #'(? Mu? (app (lambda (t) (Mu-body t)) bp))])))
(define-match-expander Poly-unsafe:
(lambda (stx)
(syntax-case stx ()
[(_ n bp) #'(? Poly? (app (lambda (t) (list (Poly-n t) (Poly-body t))) (list n bp)))])))
(define-match-expander PolyDots-unsafe:
(lambda (stx)
(syntax-case stx ()
[(_ n bp) #'(? PolyDots? (app (lambda (t) (list (PolyDots-n t) (PolyDots-body t))) (list n bp)))])))
(define-match-expander Mu:*
(lambda (stx)
(syntax-case stx ()
[(_ np bp)
#'(? Mu?
(app (lambda (t) (let ([sym (gensym)])
(list sym (Mu-body* sym t))))
(list np bp)))])))
(define-match-expander Mu-name:
(lambda (stx)
(syntax-case stx ()
[(_ np bp)
#'(? Mu?
(app (lambda (t) (let ([sym (hash-ref name-table t (lambda _ (gensym)))])
(list sym (Mu-body* sym t))))
(list np bp)))])))
;; These match expanders correspond to opening up a type in
;; locally nameless representation. When the type is opened,
;; the nameless bound variables are replaced with free
;; variables with names.
;;
;; This match expander wraps the smart constructor
;; names are generated with gensym
(define-match-expander Poly:*
(lambda (stx)
(syntax-case stx ()
[(_ nps bp)
#'(? Poly?
(app (lambda (t)
(let* ([n (Poly-n t)]
[syms (build-list n (lambda _ (gensym)))])
(list syms (Poly-body* syms t))))
(list nps bp)))])))
;; This match expander uses the names from the hashtable
(define-match-expander Poly-names:
(lambda (stx)
(syntax-case stx ()
[(_ nps bp)
#'(? Poly?
(app (lambda (t)
(let* ([n (Poly-n t)]
[syms (hash-ref name-table t (lambda _ (build-list n (lambda _ (gensym)))))])
(list syms (Poly-body* syms t))))
(list nps bp)))])))
;; Helper for fresh match expanders below, creates a
;; fresh name that prints the same as the original
(define (fresh-name sym)
(string->uninterned-symbol (symbol->string sym)))
;; This match expander creates new fresh names for exploring the body
;; of the polymorphic type. When lexical scoping of type variables is a concern, you
;; should use this form.
(define-match-expander Poly-fresh:
(lambda (stx)
(syntax-case stx ()
[(_ nps freshp bp)
#'(? Poly?
(app (lambda (t)
(let* ([n (Poly-n t)]
[syms (hash-ref name-table t (lambda _ (build-list n (lambda _ (gensym)))))]
[fresh-syms (map fresh-name syms)])
(list syms fresh-syms (Poly-body* fresh-syms t))))
(list nps freshp bp)))])))
;; This match expander wraps the smart constructor
;; names are generated with gensym
(define-match-expander PolyDots:*
(lambda (stx)
(syntax-case stx ()
[(_ nps bp)
#'(? PolyDots?
(app (lambda (t)
(let* ([n (PolyDots-n t)]
[syms (build-list n (lambda _ (gensym)))])
(list syms (PolyDots-body* syms t))))
(list nps bp)))])))
;; This match expander uses the names from the hashtable
(define-match-expander PolyDots-names:
(lambda (stx)
(syntax-case stx ()
[(_ nps bp)
#'(? PolyDots?
(app (lambda (t)
(let* ([n (PolyDots-n t)]
[syms (hash-ref name-table t (lambda _ (build-list n (lambda _ (gensym)))))])
(list syms (PolyDots-body* syms t))))
(list nps bp)))])))
(define-match-expander PolyRow:*
(lambda (stx)
(syntax-case stx ()
[(_ nps constrp bp)
#'(? PolyRow?
(app (lambda (t)
(define sym (gensym))
(list (list sym)
(PolyRow-constraints t)
(PolyRow-body* (list sym) t)))
(list nps constrp bp)))])))
(define-match-expander PolyRow-names:
(lambda (stx)
(syntax-case stx ()
[(_ nps constrp bp)
#'(? PolyRow?
(app (lambda (t)
(define syms (hash-ref name-table t (λ _ (list (gensym)))))
(list syms
(PolyRow-constraints t)
(PolyRow-body* syms t)))
(list nps constrp bp)))])))
(define-match-expander PolyRow-fresh:
(lambda (stx)
(syntax-case stx ()
[(_ nps freshp constrp bp)
#'(? PolyRow?
(app (lambda (t)
(define syms (hash-ref name-table t (λ _ (list (gensym)))))
(define fresh-syms (list (gensym (car syms))))
(list syms fresh-syms
(PolyRow-constraints t)
(PolyRow-body* fresh-syms t)))
(list nps freshp constrp bp)))])))
;; Row*
;; This is a custom constructor for Row types
;; Sorts all clauses by the key (the clause name)
(define (Row* inits fields methods augments init-rest)
(*Row inits
(sort-row-clauses fields)
(sort-row-clauses methods)
(sort-row-clauses augments)
init-rest))
;; Class*
;; This is a custom constructor for Class types that
;; doesn't require writing make-Row everywhere
(define/cond-contract (Class* row-var inits fields methods augments init-rest)
(-> (or/c F? B? Row? #f)
(listof (list/c symbol? Type/c boolean?))
(listof (list/c symbol? Type/c))
(listof (list/c symbol? Type/c))
(listof (list/c symbol? Type/c))
(or/c Type/c #f)
Class?)
(*Class row-var (Row* inits fields methods augments init-rest)))
;; Class:*
;; This match expander replaces the built-in matching with
;; a version that will merge the members inside the substituted row
;; with the existing fields.
;; helper function for the expansion of Class:*
;; just does the merging
(define (merge-class/row class-type)
(define row (Class-row-ext class-type))
(define class-row (Class-row class-type))
(define inits (Row-inits class-row))
(define fields (Row-fields class-row))
(define methods (Row-methods class-row))
(define augments (Row-augments class-row))
(define init-rest (Row-init-rest class-row))
(cond [(and row (Row? row))
(define row-inits (Row-inits row))
(define row-fields (Row-fields row))
(define row-methods (Row-methods row))
(define row-augments (Row-augments row))
(define row-init-rest (Row-init-rest row))
(list row
;; Init types from a mixin go at the start, since
;; mixins only add inits at the start
(append row-inits inits)
;; FIXME: instead of sorting here every time
;; the match expander is called, the row
;; fields should be merged on substitution
(sort-row-clauses (append fields row-fields))
(sort-row-clauses (append methods row-methods))
(sort-row-clauses (append augments row-augments))
;; The class type's existing init-rest types takes
;; precedence since it's the one that was already assumed
;; (say, in a mixin type's domain). The mismatch will
;; be caught by application type-checking later.
(if init-rest init-rest row-init-rest))]
[else (list row inits fields methods augments init-rest)]))
;; sorts the given field of a Row by the member name
(define (sort-row-clauses clauses)
(sort clauses symbol<? #:key car))
(define-match-expander Class:*
(λ (stx)
(syntax-case stx ()
[(_ row-pat inits-pat fields-pat methods-pat augments-pat init-rest-pat)
#'(? Class?
(app merge-class/row
(list row-pat inits-pat fields-pat
methods-pat augments-pat init-rest-pat)))])))
;; alternative to Name: that only matches the name part
(define-match-expander Name/simple:
(λ (stx)
(syntax-parse stx
[(_ name-pat) #'(Name: name-pat _ _)])))
;; alternative to Name: that only matches struct names
(define-match-expander Name/struct:
(λ (stx)
(syntax-parse stx
[(_) #'(Name: _ _ #t)]
[(_ name-pat) #'(Name: name-pat _ #t)])))
| false |
8b303ee403934ec5fe14acd98e78d362a2538ce6 | 8ad2bcf76a6bda64f509da5f0844e0285f19d385 | /redex-challenge2b.rkt | 37b0247a192444cd614c0bb389c8211870a00926 | []
| no_license | jeapostrophe/exp | c5efae0ea7068bb5c8f225df6de45e6c4fa566bd | 764265be4bcd98686c46ca173d45ee58dcca7f48 | refs/heads/master | 2021-11-19T00:23:11.973881 | 2021-08-29T12:56:11 | 2021-08-29T12:56:11 | 618,042 | 39 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 1,573 | rkt | redex-challenge2b.rkt | #lang racket/load
(module redex racket
(require redex/reduction-semantics
tests/eli-tester)
(define-language mt
[t (number ...)])
(define red
(reduction-relation
mt #:domain t
(--> (number_1 ...
number_2
number_3 ...
number_4
number_5 ...)
(number_2 number_4))))
(time
(test
(apply-reduction-relation red (term (1 2 3)))
=>
(list (term (1 2))
(term (1 3))
(term (2 3))))))
(require 'redex)
(collect-garbage) (collect-garbage)
(module jay racket
(require racket/generator
tests/eli-tester)
(struct mt:t (ns) #:transparent)
(define-syntax-rule (term d) (->mt:t 'd))
(define ->mt:t
(match-lambda
[(list (? number? n) ...)
(mt:t n)]))
(define apply-reduction-relation
(match-lambda
[(mt:t n)
(for*/list ([n2*after2
(in-generator
(let loop ([n n])
(unless (empty? n)
(yield n)
(loop (cdr n)))))]
[n4*after4
(in-generator
(let loop ([n (cdr n2*after2)])
(unless (empty? n)
(yield n)
(loop (cdr n)))))])
(mt:t (list (car n2*after2) (car n4*after4))))]))
(time
(test
(apply-reduction-relation (term (1 2 3)))
=>
(list (term (1 2))
(term (1 3))
(term (2 3))))))
(require 'jay) | true |
0431a8f25529a5d76ff25498495acdfa39733599 | d249d9b7746f858904b74f78630e859ae6553e9b | /chapter7.rkt | 91745e586166aa2b75df601f91f8b42ce7a17652 | []
| no_license | hristoyankov/little-schemer | 9054eb2a887135565bec5347eae5892ba06f5092 | 14768db410383d766c39168cfac8bd7b4cdb7623 | refs/heads/master | 2022-04-13T15:23:39.140017 | 2020-04-04T20:52:57 | 2020-04-04T20:52:57 | 112,762,027 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 4,653 | rkt | chapter7.rkt | #lang racket
(require "preface.rkt")
(require "chapter2.rkt")
(require "chapter3.rkt")
(provide a-pair?)
(provide first)
(provide second)
(provide build)
(provide revpair)
(define set?
(lambda (lat)
(cond
((null? lat) #t)
((member? (car lat) (cdr lat)) #f)
(else (set? (cdr lat))))))
(eq? #f (set? '(apple peaches apple plum)))
(eq? #t (set? '(apple peaches pears plum)))
(eq? #t (set? '()))
(eq? #f (set? '(apple 3 pear 4 apple 3)))
(define makeset
(lambda (lat)
(cond
((null? lat) '())
(else (cons (car lat)
(makeset (multirember (car lat) (cdr lat))))))))
(equal? '(apple peach pear plum lemon)
(makeset '(apple peach pear peach plum apple lemon peach)))
(define subset?
(lambda (set1 set2)
(cond
((null? set1) #t)
(else (and (member? (car set1) set2)
(subset? (cdr set1) set2))))))
(eq? #t (subset? '(5 chicken wings)
'(5 hamburgers 2 pieces fried chicken and light duckling wings)))
(eq? #f (subset? '(4 pounds of horseradish)
'(four pounds chicken and 5 ounces horseradish)))
(define eqset?
(lambda (set1 set2)
(and (subset? set1 set2)
(subset? set2 set1))))
(eq? #t (eqset? '(6 large chickens with wings)
'(6 chickens with large wings)))
(define intersect?
(lambda (set1 set2)
(cond
((null? set2) #f)
(else (or (member? (car set2) set1)
(intersect? set1 (cdr set2)))))))
(eq? #t (intersect? '(stewed tomatoes and macaroni)
'(macaroni and cheese)))
(define intersect
(lambda (set1 set2)
(cond
((null? set1) '())
((member? (car set1) set2)
(cons (car set1) (intersect (cdr set1) set2)))
(else (intersect (cdr set1) set2)))))
(equal? '(and macaroni) (intersect '(stewed tomatoes and macaroni)
'(macaroni and cheese)))
(define union
(lambda (set1 set2)
(cond
((null? set1) set2)
((member? (car set1) set2) (union (cdr set1) set2))
(else (cons (car set1) (union (cdr set1) set2))))))
(equal? '(stewed tomatoes casserole macaroni and cheese)
(union '(stewed tomatoes and macaroni casserole)
'(macaroni and cheese)))
(define difference
(lambda (set1 set2)
(cond
((null? set1) '())
((member? (car set1) set2)
(difference (cdr set1) set2))
(else (cons (car set1)
(difference (cdr set1) set2))))))
(define intersectall
(lambda (lset)
(cond
((null? (cdr lset)) (car lset))
(else (intersect (car lset)
(intersectall (cdr lset)))))))
(equal? '(a) (intersectall '((a b c) (c a d e) (e f g h a b))))
(equal? '(6 and) (intersectall '((6 pears and)
(3 peaches and 6 peppers)
(8 pears and 6 plums)
(and 6 prunes with some apples))))
(define a-pair?
(lambda (x)
(cond
((atom? x) #f)
((null? x) #f)
((null? (cdr x)) #f)
((null? (cdr (cdr x))) #t)
(else #f))))
(eq? #t (a-pair? '(pear pear)))
(eq? #t (a-pair? '(3 6)))
(eq? #t (a-pair? '((2) (pair))))
(eq? #t (a-pair? '(full (house))))
(define first
(lambda (p)
(car p)))
(define second
(lambda (p)
(car (cdr p))))
(define third
(lambda (p)
(car (cdr (cdr p)))))
(define build
(lambda (s1 s2)
(cons s1 (cons s2 '()))))
(define fun?
(lambda (rel)
(set? (firsts rel))))
(eq? #t (fun? '((8 3) (4 2) (7 6) (6 2) (3 4))))
(eq? #f (fun? '((d 4) (b 0) (b 9) (e 5) (g 4))))
(define revrel1
(lambda (rel)
(cond
((null? rel) '())
(else (cons (build (second (car rel))
(first (car rel)))
(revrel1 (cdr rel)))))))
(define revpair
(lambda (p)
(build (second p) (first p))))
(define revrel
(lambda (rel)
(cond
((null? rel) '())
(else (cons (revpair (car rel))
(revrel (cdr rel)))))))
(equal? '((a 8) (pie pumpkin) (sick got))
(revrel '((8 a) (pumpkin pie) (got sick))))
(define seconds
(lambda (rel)
(cond
((null? rel) '())
(else (cons (second (car rel))
(seconds (cdr rel)))))))
(define fullfun?
(lambda (fun)
(set? (seconds fun))))
(eq? #f (fullfun? '((8 3) (4 2) (7 6) (6 2) (3 4))))
(eq? #t (fullfun? '((8 3) (4 8) (7 6) (6 2) (3 4))))
(eq? #f (fullfun? '((grape raisin)
(plum prune)
(stewed prune))))
(eq? #t (fullfun? '((grape raisin)
(plum prune)
(stewed grape))))
| false |
de6eadab42ede64b2056c6966df025f281700683 | d6b905b841a3c812ff1805879f681111f164e87c | /itscaleb/ch13/server.rkt | 548764c3e10f0d7f6bb468ee631aa99a06db718a | [
"MIT"
]
| permissive | SeaRbSg/realm_of_racket | 40398e89ab2d39b7499bb97ee2a6b07bdb79c586 | b4383c6cab68b4cea04f514267c58397e8cc69d0 | refs/heads/master | 2021-03-12T22:50:14.935166 | 2017-11-30T23:40:10 | 2017-11-30T23:51:11 | 12,911,347 | 1 | 2 | null | null | null | null | UTF-8 | Racket | false | false | 1,025 | rkt | server.rkt | #lang racket
(require 2htdp/image 2htdp/universe "shared.rkt")
(provide launch-guess-server)
(struct interval (small big))
(define u0 (interval LOWER UPPER))
(define (launch-guess-server)
(universe #f
(on-new connect)
(on-msg handle-msg)))
(define (connect u client)
(if (false? u)
(make-bundle u0 (list (make-mail client (guess u0))) '())
(make-bundle u empty (list client))))
(define (handle-msg u client msg)
(define w (next-interval u msg))
(make-bundle w (list (make-mail client (guess w))) '()))
(define (next-interval u msg)
(cond [(not (string? msg)) u]
[(string=? "up" msg) (bigger u)]
[(string=? "down" msg) (smaller u)]
[else u]))
(define (smaller u)
(interval (interval-small u)
(max (interval-small u)(sub1 (guess u)))))
(define (bigger u)
(interval (min (interval-big u)(add1 (guess u)))
(interval-big u)))
(define (guess u)
(quotient (+ (interval-small u)(interval-big u)) 2))
(define (single? u)
(= (interval-small u)(interval-big u)))
| false |
d28392848f2c7e8b774039e158c591aa2e464ba9 | 7b04163039ff4cea3ac9b5b6416a134ee49ca1e4 | /t/struct.t | 9211fb2f39aa0983dc3c21b270d5a1761adfe284 | []
| no_license | dstorrs/racket-dstorrs-libs | 4c94219baf3c643a696aa17ed0e81d4a0ab18244 | 7e816d2b5f65a92ab01b29a320cc2c71d7870dbb | refs/heads/master | 2022-08-27T22:31:38.985194 | 2022-08-05T21:35:35 | 2022-08-05T21:35:35 | 68,236,201 | 6 | 1 | null | 2018-10-19T15:37:12 | 2016-09-14T19:24:52 | Racket | UTF-8 | Racket | false | false | 4,492 | t | struct.t | #!/usr/bin/env racket
#lang at-exp racket/base
(require racket/format
racket/function
racket/match
"../struct.rkt"
"../test-more.rkt")
(expect-n-tests 36)
(void (ok 1 "test harness is working"))
;; Define a struct type
(struct/kw foo (a b [c 42]) #:transparent)
(define (checker thnk description #:a [a-val 1] #:b [b-val 2] #:c [c-val 3])
(displayln (~a "entering checker"))
(match (thnk)
[(struct* foo ([a a] [b b] [c c]))
(begin
(is a a-val (~a description " => got correct a"))
(is b b-val (~a description " => got correct b"))
(is c c-val (~a description " => got correct c")))]
[_ (ok #f (~a description " => did not match"))])
(displayln (~a "leaving checker"))
)
(when #t
(test-suite
"struct/kw"
;;
;; Use normal ctor
(checker (thunk (foo 1 2 3)) "(foo 1 2 3)")
;;
;; Use keyword ctor
(checker (thunk (foo/kw #:a 1 #:b 2 #:c 3))
"(foo/kw #:a 1 #:b 2 #:c 3)") ; => (foo 1 2 3)
;;
;; Use keyword ctor, taking advantage of default arg for #:c field
(checker (thunk (foo/kw #:a 1 #:b 2)) ; => (foo 1 2 42)
"(foo/kw #:a 1 #:b 2)"
#:c 42)
;; (define (make-foo . lst)
;; (hash->struct/kw foo/kw
;; (make-hash (map cons (list 'a 'b 'c) lst))))
;; (define test-struct (make-foo 1 5 9))
;; (is test-struct (foo 1 5 9) "make-foo worked")
;; (for ([setter (list set-foo-a set-foo-b set-foo-c)]
;; [getter (list foo-a foo-b foo-c)]
;; [new-val 88])
;; (is (getter (setter test-struct new-val))
;; new-val
;; (~a "setter worked: " setter)))
))
(when #t
(test-suite
"hash->struct/kw, w/ and w/o restricted keys"
;;
;; Use a hash to create the struct
(checker (thunk (hash->struct/kw foo/kw
(hash 'a 1 'b 2 'c 3)))
"(hash->struct/kw foo/kw (hash 'a 1 'b 2 'c 3)))")
;;
;; Use a hash that has more keys than you need:
(checker (thunk (hash->struct/kw foo/kw ; => (foo/kw #:a 1 #:b 2 #:c 3)
(hash 'a 1 'b 2 'c 3 'd 5 'e 8)
'(a b c)))
"hash->struct/kw with restricted keys")
) ; test-suite
) ; when
(when #t
(test-suite
"hash->struct/kw with key remapping"
;;
;; Use a hash and rename some of the keys
(checker (thunk (hash->struct/kw foo/kw ; => (foo/kw #:a 1 #:b 2 #:c 3)
(hash 'a 1 'b 2 'charlie 3)
#:remap-keys (hash 'charlie 'c)))
"hash->struct/kw with remapped key")
;;
;; Use a hash, only some of the keys, and rename some of the keys
(checker (thunk (hash->struct/kw foo/kw (hash 'a 1 'b 2 'charlie 3 'd 5 'e 8)
'(a b charlie)
#:remap-keys (hash 'charlie 'c)))
"hash->struct/kw with restricted and remapped keys")
;;
;; Use a hash and rename the keys in non-alphabetic ways
(define arg (hash 'alpha 1 'bravo 2 'charlie 3 'delta 5 'echo 8))
(struct/kw bar (a b c d e) #:transparent)
(displayln arg)
(define res (hash->struct/kw bar/kw arg
#:remap-keys (hash 'echo 'a
'delta 'b
'charlie 'd
'bravo 'c
'alpha 'e
)))
(is (bar-a res) (hash-ref arg 'echo) "echo was remapped to a")
(is (bar-b res) (hash-ref arg 'delta) "delta was remapped to b")
(is (bar-c res) (hash-ref arg 'bravo) "bravo was remapped to c")
(is (bar-d res) (hash-ref arg 'charlie) "charlie was remapped to d")
(is (bar-e res) (hash-ref arg 'alpha) "alpha was remapped to e")
);test-suite
);when
(when #t
(test-suite
"verify-struct"
(struct foo (a b c))
(define x (foo 1 2 3))
(define y (foo 0 2 3))
(is-type x foo? "x is a foo")
(is-type y foo? "y is a foo")
(isnt x y "x and y are not equal?")
(ok (verify-struct #:struct x
#:funcs (list foo-b foo-c)
#:expected '(2 3))
"validates when given list of tests")
(ok (verify-struct #:struct x #:type foo?) "validates when given a type predicate")
))
| false |
7627407386b63fbdfb3a8c70b2ac46613341ac7b | 8a0660bd8d588f94aa429050bb8d32c9cd4290d5 | /doc/sagittarius/io.scrbl | 8daea7cd0977a204777b614bec4670356577a923 | [
"BSD-2-Clause"
]
| permissive | david135/sagittarius-scheme | dbec76f6b227f79713169985fc16ce763c889472 | 2fbd9d153c82e2aa342bfddd59ed54d43c5a7506 | refs/heads/master | 2016-09-02T02:44:31.668025 | 2013-12-21T07:24:08 | 2013-12-21T07:24:08 | 32,497,456 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,352 | scrbl | io.scrbl | @; -*- mode:scribble; coding: utf-8; -*-
@subsection[:tag "sagittarius.io"]{(sagittarius io) - Extra IO library}
@define[Library]{@name{(sagittarius io)}}
@desc{This library provided extra IO related procedures.}
@define[Function]{@name{with-input-from-port} @args{port thunk}}
@define[Function]{@name{with-output-to-port} @args{port thunk}}
@define[Function]{@name{with-error-to-port} @args{port thunk}}
@desc{Calls @var{thunk}. During evaluation of @var{thunk}, the current input
port, current output port, current error port are set to @var{port},
respectively.
}
@define[Function]{@name{call-with-input-string} @args{str proc}}
@define[Function]{@name{call-with-output-string} @args{proc}}
@define[Function]{@name{with-input-from-string} @args{str thunk}}
@define[Function]{@name{with-output-to-string} @args{thunk}}
@desc{These utility functions are trivially defined as follows;
@codeblock{
(define (call-with-input-string str proc)
(proc (open-input-string str)))
(define (call-with-output-string proc)
(let ((port (open-output-string)))
(proc port)
(get-output-string port)))
(define (with-input-from-string str thunk)
(with-input-from-port (open-input-string str) thunk))
(define (with-output-to-string thunk)
(let ((port (open-output-string)))
(with-output-to-port port thunk)
(get-output-string port)))
}
}
| false |
d02aba05e1362559d884cce063a4010d4b506164 | c6c56b3772d7496a1460af32fa32538ad8bf350f | /c3/random.rkt | 29a35dfb218d7fd6fa44ccfac46be3b0b05b2773 | []
| no_license | TienSFU25/sicp | 6adf9ff4ec5db65352643cb68c1bc259b07d0472 | 528d8ca80c4c3b306435bc988ceb60f83afc41e9 | refs/heads/master | 2021-01-20T19:20:00.180495 | 2016-06-25T02:51:06 | 2016-06-25T02:51:06 | 60,825,877 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 402 | rkt | random.rkt | #lang racket
(provide rand)
(provide random-in-range)
(provide rand-update)
(define random-init 0)
(define (rand-update x)
(let ((a 27) (b 26) (m 127))
(modulo (+ (* a x) b) m)))
(define rand (let ((x random-init))
(lambda ()
(set! x (rand-update x))
x)))
(define (random-in-range low high)
(let ((range (- high low)))
(+ low (random range)))) | false |
1083605e61a22b5f336a3186ca9e7e37f6739c08 | 310fec8271b09a726e9b4e5e3c0d7de0e63b620d | /badges/bonus.rkt | 7b47cffbb244d1e3ea9ea277649319ed4d4edc69 | [
"Apache-2.0",
"MIT"
]
| permissive | thoughtstem/badge-bot | b649f845cdc4bf62ca6bd838f57353f8e508f1ae | e535eefac26f15061c412fd0eb5b7adee158a0bf | refs/heads/master | 2022-12-14T21:55:00.173686 | 2020-09-21T19:54:15 | 2020-09-21T19:54:15 | 265,321,144 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 284 | rkt | bonus.rkt | #lang racket
(require "../badges-lang.rkt"
"../images.rkt"
"badge-colors.rkt")
;; BONUS BADGES START
(define-colored-art-badge derek-color
derek-bb1
"Derek’s Bonus Badge 1"
"https://forum.metacoders.org/t/dereks-bonus-badge-1/776"
)
;; BONUS BADGES END | false |
677f59a68f669ba2a7c649f32cb7c32408bbbfd5 | 2220a7ab162bb40e54c832bdbceed521be97b314 | /dbg-ui/info.rkt | 90699b87c1cb724f07d968a310101ea0e0d5da30 | [
"BSD-3-Clause"
]
| permissive | DavidAlphaFox/racket-dbg | 425d9365b6ff3dc76d259c96c0b50c390701c716 | b6891f7569c8789e6ac42e633fca30004ddf8a0e | refs/heads/master | 2023-08-21T05:25:49.023271 | 2021-10-03T08:16:36 | 2021-10-03T08:16:36 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 380 | rkt | info.rkt | #lang info
(define version "0.1")
(define collection "debugging")
(define deps '("base"
"dbg"
"gui-easy-lib"
"gui-lib"
"plot-lib"
"plot-gui-lib"
"profile-lib"))
(define build-deps '("rackunit-lib"))
(define raco-commands
'(("dbg" (submod debugging/ui main) "run a remote debugger" #f)))
| false |
66ef08501f31144313f22e2387537449d6459fe5 | b08b7e3160ae9947b6046123acad8f59152375c3 | /Programming Language Detection/Experiment-2/Dataset/Train/Racket/sorting-algorithms-counting-sort-1.rkt | b2e538d927abf3da14724ce3d6ac46be14ffad50 | []
| no_license | dlaststark/machine-learning-projects | efb0a28c664419275e87eb612c89054164fe1eb0 | eaa0c96d4d1c15934d63035b837636a6d11736e3 | refs/heads/master | 2022-12-06T08:36:09.867677 | 2022-11-20T13:17:25 | 2022-11-20T13:17:25 | 246,379,103 | 9 | 5 | null | null | null | null | UTF-8 | Racket | false | false | 368 | rkt | sorting-algorithms-counting-sort-1.rkt | #lang racket
(define (counting-sort xs min max)
(define ns (make-vector (+ max (- min) 1) 0))
(for ([x xs]) (vector-set! ns (- x min) (+ (vector-ref ns (- x min)) 1)))
(for/fold ([i 0]) ([n ns] [x (in-naturals)])
(for ([j (in-range i (+ i n ))])
(vector-set! xs j (+ x min)))
(+ i n))
xs)
(counting-sort (vector 0 9 3 8 1 -1 1 2 3 7 4) -1 10)
| false |
48692ecf11d1f2eb42c4f7f7fb2294e8d3f987cb | 89fb2d20d243de8c36fe35fa57df6d414b0e512a | /src/sicp/ex4_8.rkt | 68a84ad457b69ed46c269a32ce1fa3bf2b502b4b | []
| no_license | 404pnf/sicp-1 | 52d358764380a06b46e69cf0e6e19d99b870bdf4 | 5158bd64ca487b858c9d95e8a2bccb81fe2113a7 | refs/heads/master | 2020-12-31T06:32:08.416974 | 2013-07-26T08:26:49 | 2013-07-26T08:26:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,608 | rkt | ex4_8.rkt | #lang racket
(provide let->combination let?)
(define (tagged-list? exp tag)
(if (pair? exp)
(eq? (car exp) tag)
#f))
(define (variable? expr)
(symbol? expr))
(define (make-lambda params body)
(cons 'lambda (cons params body)))
(define (let? expr)
(tagged-list? expr 'let))
(define (named-let? expr)
(if (variable? (cadr expr))
#t
#f))
(define (let-name expr)
(if (named-let? expr)
(cadr expr)
#f))
(define (let-bindings expr)
(if (let-name expr)
(caddr expr)
(cadr expr)))
(define (let-bindings-variables bindings) (map car bindings))
(define (let-bindings-values bindings) (map cadr bindings))
(define (let-body expr)
(if (let-name expr)
(cdddr expr)
(cddr expr)))
(define (let->combination expr)
(let ([bindings (let-bindings expr)])
(let ([vars (let-bindings-variables bindings)]
[vals (let-bindings-values bindings)]
[body (let-body expr)])
(if (not (let-name expr))
(cons (make-lambda vars body) vals)
(list 'begin
(list 'define (let-name expr) (make-lambda vars body))
(list (let-name expr) vals))))))
(define ns (make-base-namespace))
(eval (let->combination '(let ((x 2) (y 3)) (+ x y))) ns)
(eval (let->combination '(let ((x 2) (y 3)) (+ x y))) ns)
(let->combination '(let fib-iter ((a 1)
(b 0)
(count n))
(if (= count 0)
b
(fib-iter (+ a b) a (- count 1)))))
| false |
7233a233c51449ee5970a6a5d165e743f6f2c3f4 | 6c5b22767a683f9588914208ee4fb4811c760c21 | /utils.rkt | f60062a52e75832d91a8cc406c21b70bd59c6599 | [
"MIT"
]
| permissive | unjordy/literally | c7e56e3461d10dcd9af8cdce7afab315f4f128e6 | 8740a7a7ce0102a3e138397de67fd0d83f3d04e5 | refs/heads/master | 2016-09-13T17:08:31.822538 | 2016-05-02T04:37:20 | 2016-05-02T04:37:20 | 57,598,136 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 519 | rkt | utils.rkt | #lang racket/base
(require racket/string)
(provide current-indent-level
tab
t)
(define current-indent-level (make-parameter 0))
(define (tab . text)
(parameterize ([current-indent-level (+ (current-indent-level) 1)])
(let ([indent (make-string (current-indent-level) #\tab)])
(string-append indent
(string-replace (string-join text "")
"\n"
(string-append "\n" indent))))))
(define t tab)
| false |
0a2018301fea5f704b6c8ed97c86db09910c80fd | a2e3f2a2ec80a49882578fef1ba5fd49a48e25eb | /processing/ast/errors.rkt | fc3957b6706ae2878c673dafc0f4a6f7b5a9ced4 | [
"MIT"
]
| permissive | hfcorreia/p2r | 91d43af56123e32ba83f64a9e7c7a4670e9264dd | 4a4f05db2e1dc07ad5f343151ff3a037417d72e4 | refs/heads/master | 2021-01-19T17:07:57.084202 | 2015-10-07T13:07:42 | 2015-10-07T13:07:42 | 41,046,859 | 5 | 1 | null | 2015-08-19T16:55:15 | 2015-08-19T16:44:55 | null | UTF-8 | Racket | false | false | 1,705 | rkt | errors.rkt | #lang racket
(provide (all-defined-out))
(require "types.rkt")
(define (build-type-string t)
(if (array-type? t)
(string-append* (symbol->string (send (send t get-type) get-type))
(make-list (send t get-dims) "[]"))
(send t get-type)))
(define (boolean-conversion-error obj t)
(let ([t (build-type-string t)])
(send obj type-error (format "Cannot convert a ~a to boolean" t))))
(define (type-conversion-error obj t1 t2)
(let ([t1 (build-type-string t1)]
[t2 (build-type-string t2)])
(send obj type-error (format "Cannot convert a ~a to ~a" t1 t2))))
(define (binary-error obj op t1 t2)
(let ([t1 (build-type-string t1)]
[t2 (build-type-string t2)])
(send obj
type-error
(format "The operator ~a is undefined for argument types(s) ~a,~a"
op t1 t2))))
(define (unary-error obj op t)
(let ([t (build-type-string t)])
(send obj
type-error
(format "The operator ~a is undefined for argument types(s) ~a"
op t))))
(define (array-type-error obj id)
(send obj read-error (format "~a is not of type array." id)))
(define (binding-not-found obj id)
(send obj read-error (format "Cannot find anything named \"~a\"" id)))
(define (method-not-applicable obj id types)
(send obj read-error (format "The method ~a is not applicable for arguments ~a" id types)))
(define (return-error obj)
(send obj read-error (format "Unreachable code")))
(define (duplicate-variable obj id)
(send obj read-error (format "Duplicate local variable ~a" id)))
(define (duplicate-method obj id args)
(send obj read-error (format "Duplicate method ~a~a" id args)))
| false |
10cbc519fd3d0c7244c1ff278b9f8976d5edbf30 | 45c94c43fae618758a0b2d9a24aa5d1c771f107e | /http/util.rkt | 7d21690f05024cbe74c061541ae2e59014a19aa3 | [
"BSD-2-Clause",
"BSD-3-Clause"
]
| permissive | greghendershott/http | df49794790c86c33cdf38d143aa7e8bd14bf6017 | e9750c32d07e796bfea2bac33e3ec50145461a65 | refs/heads/master | 2022-12-02T10:19:48.882514 | 2022-11-25T15:34:10 | 2022-11-25T15:34:10 | 5,463,511 | 22 | 7 | null | 2017-11-06T14:45:09 | 2012-08-18T15:03:20 | Racket | UTF-8 | Racket | false | false | 1,883 | rkt | util.rkt | ;; Copyright (c) 2012-2022 by Greg Hendershott.
;; SPDX-License-Identifier: BSD-2-Clause
#lang racket
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Convenience macros to define contract and/or provide (similar to
;; define/contract).
(define-syntax define/contract/provide
(syntax-rules ()
[(_ (id . args) contract body ...)
(begin
(define/contract (id . args) contract body ...)
(provide/contract [id contract]))]
[(_ id contract expr)
(begin
(define/contract id contract expr)
(provide/contract [id contract]))] ))
(define-syntax define/provide
(syntax-rules ()
[(_ (id . args) body ...)
(begin
(define (id . args) body ...)
(provide id))]
[(_ id expr)
(begin
(define id expr)
(provide id))] ))
(provide define/contract/provide
define/provide)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (any/c ... -> string?) Given any number of Racket identifiers or
;; literals, convert them to a string. Non-literals are printed as
;; "expression = value". For use with e.g. log-debug which takes a
;; single string? not format or printf style, plus, we want to show
;; the expression = value thing, too.
(define-syntax tr
(syntax-rules ()
[(_ e)
(if (or (string? (syntax-e #'e))
(number? (syntax-e #'e)))
(format "~a" e)
(format "~s=~a"
(syntax->datum #'e)
e))]
[(_ e0 e1 ...)
(string-append (tr e0)
" "
(tr e1 ...))]))
(provide tr)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-logger http)
(provide http-logger
log-http-fatal
log-http-error
log-http-warning
log-http-info
log-http-debug)
| true |
f1485b45109c9276aed9396ef4c0f7f839baad74 | 2cfd2e7dbfec688de9d738a7ff047e3227678b8f | /healer-animal-enemies/examples.rkt | 20e4fd9d56864a18ed0a68fe0b7899ebf20eb1d9 | [
"Apache-2.0"
]
| permissive | thoughtstem/TS-K2-Languages | 52376f33ea8471da71edf50fe0708ec5bd0b0271 | 680ef0c5d8f9265a0114a612c25aa16c55abec88 | refs/heads/master | 2020-08-05T08:24:48.444660 | 2020-02-29T00:44:08 | 2020-02-29T00:44:08 | 212,463,806 | 0 | 0 | null | 2020-02-29T00:44:09 | 2019-10-02T23:52:06 | Racket | UTF-8 | Racket | false | false | 346 | rkt | examples.rkt | #lang racket
(require healer-lib/examples-lib "./main.rkt")
(define-enemies-examples
#:lang healer-animal-enemies
#:start start
#:avatars (llama horse cow rabbit)
#:foods (apple kiwi strawberry grapes)
#:friends (pig dog wolf llama)
#:colors (red orange yellow green blue purple)
#:enemies (pig dog wolf llama)
#:rand rand)
| false |
330dff69061008874a2821ae89eee703df65490b | 2648ed01abe9e761560bf1cd79d5da122ac8266f | /tests/private/subst.rkt | d83e990778d6636865f2134d315aaa612c150963 | [
"MIT",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/datalog | 74a783a54a79e86a8d040848e8476fe6bd68d2f9 | 3a30258c7a11f6f1836f52590e26542c11865714 | refs/heads/master | 2023-08-18T02:06:23.735559 | 2022-03-31T08:01:51 | 2022-03-31T13:15:17 | 27,412,704 | 40 | 17 | NOASSERTION | 2022-03-31T13:15:18 | 2014-12-02T03:13:48 | Racket | UTF-8 | Racket | false | false | 5,843 | rkt | subst.rkt | #lang racket
(require rackunit
datalog/private/subst
datalog/ast
datalog/private/env)
(require/expose datalog/private/subst (subst-literal shuffle))
(provide subst-tests)
(define (gensym-var? v)
(define s (variable-sym v))
(not (eq? s (string->symbol (symbol->string s)))))
(define subst-tests
(test-suite
"subst"
(test-suite
"subst-term"
(test-equal? "con"
(subst-term (empty-env) (make-constant #f 'v1))
(make-constant #f 'v1))
(test-equal? "var def"
(subst-term (empty-env) (make-variable #f 'v1))
(make-variable #f 'v1))
(test-equal? "var"
(subst-term (extend (empty-env) 'v1 (make-constant #f 'v1)) (make-variable #f 'v1))
(make-constant #f 'v1)))
(test-suite
"subst-literal"
(test-equal? "con"
(subst-literal (empty-env) (make-literal #f 'lit (list (make-constant #f 'v1))))
(make-literal #f 'lit (list (make-constant #f 'v1))))
(test-equal? "var def"
(subst-literal (extend (empty-env) 'v1 (make-constant #f 'v1)) (make-literal #f 'lit (list (make-variable #f 'v1))))
(make-literal #f 'lit (list (make-constant #f 'v1))))
(test-equal? "var def"
(subst-literal (extend (empty-env) 'v1 (make-constant #f 'v1)) (make-literal #f 'lit (list (make-variable #f 'v1))))
(make-literal #f 'lit (list (make-constant #f 'v1)))))
(test-suite
"subst-clause"
(test-equal? "con"
(subst-clause (empty-env) (make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(test-equal? "var def"
(subst-clause (extend (empty-env) 'v1 (make-constant #f 'v1))
(make-clause #f (make-literal #f 'lit (list (make-variable #f 'v1))) empty))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(test-equal? "var def"
(subst-clause (extend (empty-env) 'v1 (make-constant #f 'v1))
(make-clause #f (make-literal #f 'lit (list (make-variable #f 'v1))) empty))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(test-equal? "con"
(subst-clause (empty-env) (make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1)))
(list (make-literal #f 'lit (list (make-constant #f 'v1))))))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1)))
(list (make-literal #f 'lit (list (make-constant #f 'v1))))))
(test-equal? "var def"
(subst-clause (extend (empty-env) 'v1 (make-constant #f 'v1))
(make-clause #f (make-literal #f 'lit (list (make-variable #f 'v1)))
(list (make-literal #f 'lit (list (make-variable #f 'v1))))))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1)))
(list (make-literal #f 'lit (list (make-constant #f 'v1))))))
(test-equal? "var def"
(subst-clause (extend (empty-env) 'v1 (make-constant #f 'v1))
(make-clause #f (make-literal #f 'lit (list (make-variable #f 'v1)))
(list (make-literal #f 'lit (list (make-variable #f 'v1))))))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1)))
(list (make-literal #f 'lit (list (make-constant #f 'v1)))))))
(test-suite
"shuffle"
(test-equal? "con"
(shuffle (empty-env) (make-literal #f 'lit (list (make-constant #f 'v1))))
(empty-env))
(test-equal? "var"
(shuffle (extend (empty-env) 'v1 (make-constant #f 'k1)) (make-literal #f 'lit (list (make-variable #f 'v1))))
(extend (empty-env) 'v1 (make-constant #f 'k1)))
(test-not-false "var"
(gensym-var? (lookup (shuffle (empty-env)
(make-literal #f 'lit (list (make-variable #f 'v1))))
'v1))))
(test-suite
"rename-question"
(test-equal? "l" (rename-question (make-literal #f 'lit (list (make-constant #f 'v1))))
(make-literal #f 'lit (list (make-constant #f 'v1))))
(test-not-false "l"
(gensym-var?
(first
(literal-terms
(rename-question (make-literal #f 'lit (list (make-variable #f 'v1)))))))))
(test-suite
"rename-clause"
(test-equal? "c" (rename-clause (make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1))) empty))
(test-not-false "c"
(gensym-var?
(first
(literal-terms
(clause-head
(rename-clause (make-clause #f (make-literal #f 'lit (list (make-variable #f 'v1))) empty)))))))
(test-not-false "c"
(gensym-var?
(first
(literal-terms
(first
(clause-body
(rename-clause (make-clause #f (make-literal #f 'lit (list (make-constant #f 'v1)))
(list (make-literal #f 'lit (list (make-variable #f 'v1)))))))))))))))
| false |
f8c1055b392b09fd45a8c1417fd88f376e5149df | eb48ced56feaf37d1f1439589894353a5d0a50f8 | /cKanren/src/constraint-interactions.rkt | c3014ec0f22f04803222abd9501bb45664fef8ac | [
"MIT"
]
| permissive | ReinoutStevens/cKanren | f40eaad090865f4b326d35e4f90738ff985aefbb | b388b60c5487bce1d0ea84a0149347197e80643a | refs/heads/master | 2020-12-27T09:13:45.121481 | 2013-09-08T22:31:39 | 2013-09-08T22:31:51 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,741 | rkt | constraint-interactions.rkt | #lang racket
(require "helpers.rkt" "package.rkt" "ocs.rkt" "constraint-store.rkt"
"constraints.rkt")
(require (for-syntax syntax/parse racket/syntax))
(provide (all-defined-out))
(define constraint-interactions
(make-parameter '()))
(define extend-constraint-interactions
(extend-parameter constraint-interactions))
(define-syntax (define-constraint-interaction stx)
(syntax-parse stx
[(define-constraint-interaction
name:id
(constraint-exprs ...)
(~or (~optional (~seq #:package (a:id : s:id c:id))))
...
clauses ...)
(define a-name (or (attribute a) (generate-temporary #'?a)))
(define s-name (or (attribute s) (generate-temporary #'?s)))
(define c-name (or (attribute c) (generate-temporary #'?c)))
(with-syntax*
([(a s c) (list a-name s-name c-name)]
[constraint-interaction-expr
#`(parse-constraint-interaction
name (constraint-exprs ...) (clauses ...)
(a s c))])
#'(extend-constraint-interactions
'name constraint-interaction-expr))]))
(define-syntax (parse-constraint-interaction stx)
(syntax-parse stx
[(parse-constraint-interaction
name
((rator rands ...) ...)
([pred? (constraints ...)] ...)
(a s c))
(with-syntax
([(arg ...) (generate-temporaries #'(rator ...))])
#`(let ()
(define (run-interaction . arg*)
(lambdam@/private (a : ?s ?c ?q ?t)
(let ([s (substitution-s ?s)]
[c (constraint-store-c ?c)])
(match (map oc-rands arg*)
[`((rands ...) ...)
(cond
[pred?
(let ([new-c (remq*-c arg* c)])
(let ([new-a (make-a ?s (constraint-store new-c) ?q ?t)])
((composem constraints ...) new-a)))]
...
[else #f])]
;; when the rators are all correct but the pattern
;; is more strict than we were expecting, we should
;; fail instead of erroring
[_ #f]))))
(define (name oc)
(let ([this-rator (oc-rator oc)])
(lambdam@ (a : s c)
(generate-cond run-interaction (a s c) oc this-rator
() ((rator rands ...) ...)))))
name))]))
(define-syntax (generate-cond stx)
(syntax-parse stx
[(generate-cond run-interaction (a s c) oc this-rator (pattern ...) ()) #'#f]
[(generate-cond
run-interaction (a s c) oc this-rator
((rator-pre rand-pre ...) ...)
((rator rand ...) (rator-post rand-post ...) ...))
(with-syntax
([(pre ...) (generate-temporaries #'(rator-pre ...))]
[(post ...) (generate-temporaries #'(rator-post ...))]
[(pre-ocs ...) #'((filter/rator 'rator-pre c) ...)]
[(post-ocs ...) #'((filter/rator 'rator-post c) ...)]
[pattern-applies? #'(eq? 'rator this-rator)])
(with-syntax
([run-rule
#'(bindm a
(for*/fold
([fn mzerom])
([pre pre-ocs] ...
[this (list oc)]
[post post-ocs] ...)
(lambdam@
(a : s c)
(cond
[((run-interaction pre ... this post ...) a)]
[else (fn a)]))))]
[rest-formatted
#'(generate-cond
run-interaction (a s c) oc this-rator
((rator-pre rand-pre ...) ... (rator rand ...))
((rator-post rand-post ...) ...))])
#'(or (and pattern-applies? run-rule) rest-formatted)))]))
| true |
44f3b3e7056d6d310f4290642e176e1fa2f2a4f4 | e3cfbb9a978d3ac739d7a623bc8982d3dee1ba64 | /quick.rkt | 7b49953968791a06c51d2a7f4911c9cce0e37ac7 | []
| no_license | xuchunyang/learn-racket | 7cbeb1545c519705bb8759851c2d104760163203 | 13ca916e5eafa7f4de141034fe65a2f99c2b7f71 | refs/heads/master | 2020-03-22T17:10:47.754872 | 2020-01-17T17:24:08 | 2020-01-17T17:24:08 | 140,378,786 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 224 | rkt | quick.rkt | #lang slideshow
(provide rainbow square)
(define (square n)
(filled-rectangle n n))
(define (rainbow p)
(map (lambda (color)
(colorize p color))
(list "red" "orange" "yellow" "green" "blue" "purple")))
| false |
8261cf32ce778c2cc9b241c354b5a02f1ed0f738 | 0bd832b9b372ee7d4877e99b68536c15a7f7c9c9 | /symbols.rkt | c18614f4a833333ac561b5d412969884ad803c5f | []
| no_license | jwilliamson1/schemer | eff9c10bcbcdea9110a44c80769a0334119b3da4 | c2f9743392652664f1ff5687819f040e724c8436 | refs/heads/master | 2022-01-06T14:52:10.638822 | 2021-12-31T21:32:22 | 2021-12-31T21:32:22 | 75,143,723 | 0 | 0 | null | 2020-11-11T13:11:47 | 2016-11-30T02:37:55 | Racket | UTF-8 | Racket | false | false | 4,948 | rkt | symbols.rkt | #lang racket
(cons 'a 'b)
(cons 'a 2)
(define b 3)
(cons 'a b)
(car '(a b c))
(cadddr (quote(a b c 3)))
(list 'a 'b 'c 'abc)
;'(a b c)
(list (list 'george))
;'((george))
(cdr '((x1 x2) (y1 y2)))
;'((y1 y2))
(cadr '((x1 x2) (y1 y2)))
;'(y1 y2)
(pair? (car '(a short list)))
;false
(memq 'red '((red shoes) (blue socks)))
;false
(memq 'red '(red shoes blue socks))
;true
;(define (equal? a b)
; (or
; (eq? a b)
; (and
; (pair? a)
; (pair? b)
; (equal? (car a)(car b))
; (equal? (cdr a)(cdr b)))))
(car '(a b c))
(car (quote (a b c)))
(car '(list 'quote a b c))
(car '(quote a))
(define (=number? exp num)
(and (number? exp) (= exp num)))
(define (variable? x) (symbol? x))
(define (same-variable? v1 v2)
(and (variable? v1)
(variable? v2)
(eq? v1 v2)))
(define (make-exponentiation b e)
(cond((and (=number? b 0)(=number? e 0))error "Zero to the zeroth power is undefined.")
((=number? e 0) 1)
((=number? e 1) b)
((and (number? b) (number? e))
(expt b e))
(else (list '^ b e))))
(displayln "make-exponentation test")
(make-exponentiation 0 0); undefined
(make-exponentiation 0 1); 0
(make-exponentiation 1 0); 1
(make-exponentiation 1 1); 1
(make-exponentiation 2 1); 2
(make-exponentiation 2 2); 4
(define (sum? x)
(and (pair? x) (eq? (car x) '+)))
(define (addend s) (cadr s))
(null? (cdddr'(+ a b c)))
(define (arb-args x)
(if(null? (cdddr x))
(caddr x)
(cons '+ (cddr x))))
(define (augend s)(arb-args s))
(define (pure-pair? p)
(cond((not(pair? p))#f)
((and(number? (cadr p))(number? (caddr p)))#t)
(else #f)))
(define (make-sum a1 a2)
(define (simplify-sums s1 s2)
(if(sum? s2)
(append s1 (cdr s2))
(append s1 (list s2))))
(cond ((=number? a1 0) a2); take care of zeros
((=number? a2 0) a1)
((and (number? a1) (number? a2))(+ a1 a2))
;if just numbers just add em
;at this point one of the arguments is not a simple number
;could be a sum, product, or exponentiation like (6 (* 5 x)) or (+ (^ x 5) 7)
;but it could be (+ x y) 3)
((sum? a1)(simplify-sums a1 a2))
((sum? a2)(append (list '+) (list a1) (cdr a2)))
; ((sum? a1)(displayln a1)
; (if(and(number? (addend a1))(pure-pair? a2))
; (make-sum(make-sum a2 (addend a1)) (augend a1))
; (make-sum(make-sum a2 (augend a1)) (addend a1))))
; ((sum? a2)(if(and(number? (addend a2))pure-pair? a1)
; (make-sum(make-sum a1 (addend a2)) (augend a2))
; (make-sum(make-sum a1 (augend a2)) (addend a2))))
(else (list '+ a1 a2))))
(displayln "make-sum test")
(make-sum '(+ x 5 5)'(* 3 y))
(make-sum '(+ x y y)'(* 3 y))
(make-sum '(* 3 y)'(+ x y))
(make-sum(make-sum 4 5)(make-sum 6 'x))
(make-sum(make-sum 4 5)(make-sum 'x 6))
(make-sum(make-sum 6 'x)(make-sum 4 5))
(make-sum(make-sum 'x 6)(make-sum 4 5))
(make-sum(make-sum 'x 6)(make-sum 4 'y))
(define (make-product m1 m2)
(cond ((or (=number? m1 0)
(=number? m2 0))
0)
((=number? m1 1) m2)
((=number? m2 1) m1)
((and (number? m1) (number? m2))
(* m1 m2))
;((product? m1))
(else (list '* m1 m2))))
(displayln "make-product test")
(make-product(make-product 'x '4)(make-product 'x 7))
(make-product(make-product 4 5)(make-product 6 7))
(define (exponentiation? x)
(and (pair? x) (eq? (car x) '^)))
(displayln "exponentiation")
(exponentiation? '(^ x 4))
(define (base e) (cadr e))
(define (exponent e) (caddr e))
(displayln "augend")
(augend '(+ a b))
(augend '(+ a b c))
(define (product? x)
(and (pair? x) (eq? (car x) '*)))
(define (multiplier p) (cadr p))
(define (multiplicand p) (arb-args p))
(define (deriv exp var)
(cond ((number? exp) 0)
((variable? exp)
(if (same-variable? exp var) 1 0))
((sum? exp)
(make-sum (deriv (addend exp) var)
(deriv (augend exp) var)))
((product? exp)
(make-sum
(make-product
(multiplier exp)
(deriv (multiplicand exp) var))
(make-product
(deriv (multiplier exp) var)
(multiplicand exp))))
((exponentiation? exp)
(make-product
(make-product (exponent exp)
(make-exponentiation
(base exp)
(- (exponent exp) 1)))
(deriv (base exp) var)))
(else (error "unknown expression
type: DERIV" exp))))
(deriv '(+ x 3) 'x)
(displayln "'(* x y) 'x)")
(deriv '(* x 3 y) 'x)
(deriv '(* (+ x y) (+ x 3)) 'x)
(deriv '(* x y (+ x 3)) 'x)
;a x 2 + b x + c -> 2 a x + b
(deriv '(+ (* a (^ x 2))(* b x) c) 'x)
(deriv '(+ (* 6 (^ x 3))(* b x) c) 'x)
(deriv '(+ (* 4(^ x 4))(* 3 (^ x 3))(* 2 (^ x 2))(* 1 (^ x 1)) ) 'x) | false |
f8614e335f34ffa8d03ed68b92049467c784a9b9 | 0bd832b9b372ee7d4877e99b68536c15a7f7c9c9 | /Chp4/4.32-inputs.rkt | 0f2a3be5fddb5e2efed0945f31be7226e7727068 | []
| no_license | jwilliamson1/schemer | eff9c10bcbcdea9110a44c80769a0334119b3da4 | c2f9743392652664f1ff5687819f040e724c8436 | refs/heads/master | 2022-01-06T14:52:10.638822 | 2021-12-31T21:32:22 | 2021-12-31T21:32:22 | 75,143,723 | 0 | 0 | null | 2020-11-11T13:11:47 | 2016-11-30T02:37:55 | Racket | UTF-8 | Racket | false | false | 1,102 | rkt | 4.32-inputs.rkt |
(define (cons x y) (lambda (m) (m x y)))
(define (car z) (z (lambda (p q) p)))
(define (cdr z) (z (lambda (p q) q)))
(define (list-ref items n)
(if (= n 0)
(car items)
(list-ref (cdr items) (- n 1))))
(define (map proc items)
(if (null? items)
'()
(cons (proc (car items))
(map proc (cdr items)))))
(define (scale-list items factor)
(map (lambda (x) (* x factor))
items))
(define (add-lists list1 list2)
(cond ((null? list1) list2)
((null? list2) list1)
(else (cons (+ (car list1)
(car list2))
(add-lists
(cdr list1)
(cdr list2))))))
(define ones (cons 1 ones))
(define integers
(cons 1 (add-lists ones integers)))
(list-ref integers 17)
(define (integral integrand initial-value dt)
(define int
(cons initial-value
(add-lists (scale-list integrand dt)
int)))
int)
(define (solve f y0 dt)
(define y (integral dy y0 dt))
(define dy (map f y))
y)
(list-ref (solve (lambda (x) x) 1 0.001) 1000)
| false |
b3694da733316ba7c324a5976d3b448901a0d882 | 162306eb8a1920949cab4e72b912a3df2a6db991 | /testcases.rkt | 5399105e35fe43b38d5f15013223cdd01f90541d | []
| no_license | arpit-1110/End-to-End-Encrypted-Chat-platform | 69aca72904a1067ec1e837fee01c9afebf543853 | b6b6b302bacce5a34f55516f7ff8358098f46526 | refs/heads/master | 2020-03-30T14:03:54.182755 | 2018-10-02T18:02:58 | 2018-10-02T18:02:58 | 151,299,615 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 532 | rkt | testcases.rkt | #lang racket
(send my-system signup 'arpit 'pass1)
(send my-system signup 'yash 'pass2)
(send my-system signup 'tushar 'pass3)
(send my-system create-chat-session 'arpit 'yash 'ATY)
(send my-system create-chat-session 'tushar 'yash 'ATY)
(send my-system send-message 'arpit 'yash "HELLO BRO" 'ATY)
(send my-system send-message 'yash 'arpit "HEY BROO" 'ATY)
(send my-system send-message 'yash 'tushar "HOW IS LIFE GOING" 'ATY)
(send my-system check-chat 'arpit)
(send my-system check-chat 'tushar)
(send my-system check-chat 'yash)
| false |
58a12b41ee3e1a03d7b0668722f1520daaa9ec52 | d755de283154ca271ef6b3b130909c6463f3f553 | /htdp-lib/htdp/bsl/runtime.rkt | d31a86cb93a8280dc8312352a9d372de115c4898 | [
"Apache-2.0",
"MIT",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | racket/htdp | 2953ec7247b5797a4d4653130c26473525dd0d85 | 73ec2b90055f3ab66d30e54dc3463506b25e50b4 | refs/heads/master | 2023-08-19T08:11:32.889577 | 2023-08-12T15:28:33 | 2023-08-12T15:28:33 | 27,381,208 | 100 | 90 | NOASSERTION | 2023-07-08T02:13:49 | 2014-12-01T13:41:48 | Racket | UTF-8 | Racket | false | false | 8,582 | rkt | runtime.rkt | #lang racket/base
(provide configure configure/settings
options->sl-runtime-settings
(struct-out sl-runtime-settings)
sl-render-value/format)
(require mzlib/pconvert
racket/pretty
lang/private/set-result
lang/private/rewrite-error-message
(prefix-in image-core: mrlib/image-core)
mrlib/cache-image-snip
(only-in racket/draw bitmap%)
racket/snip
racket/class
(only-in test-engine/test-markup get-rewritten-error-message-parameter render-value-parameter)
(only-in test-engine/syntax report-signature-violation! test)
(only-in test-engine/test-engine test-object-copy current-test-object test-object=?)
(only-in deinprogramm/signature/signature
signature? signature-name
signature-violation-proc)
(only-in simple-tree-text-markup/construct number)
simple-tree-text-markup/text
"print-width.rkt")
(struct sl-runtime-settings
(printing-style ; write, trad-write, print, quasiquote
fraction-style ; mixed-fraction, mixed-fraction-e, repeating-decimal, repeating-decimal-e
show-sharing?
insert-newlines?
tracing? ; unclear if this should be here
true/false/empty-as-ids?
abbreviate-cons-as-list?
use-function-output-syntax?
output-function-instead-of-lambda?))
(define insert-newlines (make-parameter #t))
(define (options->sl-runtime-settings options)
(sl-runtime-settings 'print
'repeating-decimal
(and (memq 'show-sharing options) #t)
#t ; insert-newlines?
#f ; tracing?
#f ; true/false/empty-as-ids?
(and (memq 'abbreviate-cons-as-list options) #t)
(and (memq 'use-function-output-syntax options) #t)
(and (memq 'output-function-instead-of-lambda options) #t)))
(define (configure options)
(configure/settings (options->sl-runtime-settings options)))
(define (configure/settings settings)
(read-decimal-as-inexact #f)
;; Set print-convert options:
(booleans-as-true/false (sl-runtime-settings-true/false/empty-as-ids? settings))
(print-boolean-long-form #t)
[constructor-style-printing
(case (sl-runtime-settings-printing-style settings)
[(quasiquote) #f]
[else #t])]
(print-as-expression #f)
(add-make-prefix-to-constructor #t)
(abbreviate-cons-as-list (sl-runtime-settings-abbreviate-cons-as-list? settings))
(insert-newlines (sl-runtime-settings-insert-newlines? settings))
(current-print-convert-hook
(let ([ph (current-print-convert-hook)])
(lambda (val basic sub)
(cond
[(and (sl-runtime-settings-output-function-instead-of-lambda? settings)
(procedure? val))
(cond
((object-name val)
=> (lambda (name)
(string->symbol (format "function:~a" name))))
(else 'function))]
[(and (not (sl-runtime-settings-true/false/empty-as-ids? settings)) (equal? val '())) ''()]
[(equal? val set!-result) '(void)]
[(signature? val)
(or (signature-name val)
'<signature>)]
[(is-image? val) val]
[else (ph val basic sub)]))))
(use-named/undefined-handler
(lambda (x)
(and (sl-runtime-settings-use-function-output-syntax? settings)
(procedure? x)
(object-name x))))
(named/undefined-handler
(lambda (x)
(string->symbol
(format "function:~a" (object-name x)))))
; sharing done by print-convert
(show-sharing (sl-runtime-settings-show-sharing? settings))
; sharing done by write
(print-graph (and (sl-runtime-settings-show-sharing? settings)
;; print-convert takes care of this also, so only do it when that doesn't happen
(case (sl-runtime-settings-printing-style settings)
([trad-write write] #t)
(else #f))))
(define img-str "#<image>")
(define (is-image? val)
(or (is-a? val image-core:image%) ; 2htdp/image
(is-a? val cache-image-snip%) ; htdp/image
(is-a? val image-snip%) ; literal image constant
(is-a? val bitmap%))) ; works in other places, so include it here too
;; exact fractions - slight hack as we know for what numbers DrRacket generates special snips
(define (use-number-markup? x)
(and (number? x)
(exact? x)
(real? x)
(not (integer? x))))
(define fraction-view
(case (sl-runtime-settings-fraction-style settings)
[(mixed-fraction mixed-fraction-e) 'mixed]
[(repeating-decimal repeating-decimal-e) 'decimal]))
(pretty-print-show-inexactness #t)
(pretty-print-exact-as-decimal (eq? fraction-view 'decimal))
(pretty-print-print-hook
(let ([oh (pretty-print-print-hook)])
(λ (val display? port)
(cond
[(and (not (port-writes-special? port))
(is-image? val))
(display img-str port)]
[(and (use-number-markup? val)
(port-writes-special? port))
(write-special (number val #:exact-prefix 'never #:inexact-prefix 'always #:fraction-view fraction-view) port)]
[(number? val)
(display (number-markup->string val #:exact-prefix 'never #:inexact-prefix 'always #:fraction-view fraction-view) port)]
[else
(oh val display? port)]))))
(pretty-print-size-hook
(let ([oh (pretty-print-size-hook)])
(λ (val display? port)
(cond
[(and (not (port-writes-special? port))
(is-image? val))
(string-length img-str)]
[(and (use-number-markup? val)
(port-writes-special? port))
1]
[(number? val)
(string-length (number-markup->string val #:exact-prefix 'never #:inexact-prefix 'always #:fraction-view fraction-view))]
[else
(oh val display? port)]))))
; test-engine
(get-rewritten-error-message-parameter get-rewriten-error-message)
; test-engine
(render-value-parameter
(lambda (value port)
(parameterize ([print-value-columns 40])
(print value port))))
(error-display-handler
(let ([o-d-h (error-display-handler)])
(λ (msg exn)
(define x (get-rewriten-error-message exn))
(o-d-h x exn))))
(global-port-print-handler
(lambda (val port [depth 0])
(define printing-style (sl-runtime-settings-printing-style settings))
(define cols
(if (exact-integer? (print-value-columns)) ;; print-value-columns takes precedence
(print-value-columns)
(htdp-print-columns)))
(parameterize ([print-value-columns (if (eqv? cols 'infinity)
+inf.0
cols)]
[pretty-print-columns
(if (sl-runtime-settings-insert-newlines? settings)
cols
'infinity)])
(let [(val (case printing-style
[(write trad-write) val]
[else (print-convert val)]))]
(case printing-style
[(print) (pretty-print val port depth)]
[(write trad-write constructor) (pretty-write val port)]
[(quasiquote) (pretty-write val port)])))))
(signature-violation-proc
(lambda (obj signature message blame-srcloc)
(report-signature-violation! obj signature message blame-srcloc)))
(let ((interaction? #f))
(current-read-interaction
(let ((old-read-interaction (current-read-interaction)))
(lambda args
; we've entered the REPL, so test once
(set! interaction? #t)
(apply old-read-interaction args))))
; in the repl, re-run tests / display results if anything has changed
(current-eval
(let ((old-eval (current-eval)))
(lambda args
(let ((test-object (test-object-copy (current-test-object))))
(dynamic-wind
void
(lambda () (apply old-eval args))
(lambda ()
(when (and interaction? (not (test-object=? test-object (current-test-object))))
(test))))))))))
(define (sl-render-value/format value port width)
(parameterize ([print-value-columns (if (eq? width 'infinity)
+inf.0
width)])
(print value port)
(unless (insert-newlines)
(newline port))))
| false |
5a32972d8df0a24f161704472aca3591ed703df3 | 8620239a442323aee50ab0802bc09ab3eacdb955 | /siek/explicate-control.rkt | 747ec8679f31042eaa6d772a4df4c2d45c33abb0 | []
| no_license | aymanosman/racket-siek-compiler | 45b9cffd93c57857fe94ba742770fc2540574705 | 85bcf2cf4881e7b68bfcd1d14e2c28712ab2e68e | refs/heads/master | 2022-10-20T08:56:49.918822 | 2021-02-02T17:23:37 | 2021-02-03T22:28:06 | 170,332,069 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 4,200 | rkt | explicate-control.rkt | #lang racket
(provide explicate-control-R1
explicate-control-R2)
(require "options.rkt"
"raise-mismatch-error.rkt")
(define (explicate-control-R2 p)
(send (new explicate-control-R2%) explicate p))
(define (explicate-control-R1 p)
(send (new explicate-control-R1%) explicate p))
(define explicate-control-R1%
(class object%
(super-new)
(define/public (who)
'explicate-control-R1)
(define/public (explicate p)
(match p
[`(program ,info ,e)
`(program
,info
,(explicate-tail 'start e))]
[_
(raise-mismatch-error (who) 'top p)]))
(define/public (explicate-tail label e)
(match e
[(or (? atom?) (? prim?))
(list (cons label `(return ,e)))]
[`(let ([,x ,e0]) ,e1)
(define l (fresh 'block))
(append (explicate-assign label e0 x `(goto ,l))
(explicate-tail l e1))]
[_
(raise-mismatch-error (who) 'tail e)]))
(define/public (explicate-assign label e v t)
(match e
[(or (? atom?) (? prim?))
(list (cons label `(seq (assign ,v ,e) ,t)))]
[`(let ([,x ,e0]) ,e1)
(define l (fresh 'block))
(append (explicate-assign label e0 x `(goto ,l))
(explicate-assign l e1 v t))]
[_
(raise-mismatch-error (who) 'assign e)]))
(define/public (atom? a)
(match a
[(? fixnum?) #t]
[(? symbol?) #t]
[_ #f]))
(define/public (prim? e)
(match e
[(or `(read ,a* ...)
`(- ,a* ...)
`(+ ,a* ...))
#:when (andmap (lambda (a) (atom? a)) a*)
#t]
[_ #f]))))
(define explicate-control-R2%
(class explicate-control-R1%
(super-new)
(define/override (who)
'explicate-control-R2)
(define/override (explicate p)
(match p
[`(program ,info ,e)
`(program
,info
,(explicate-tail 'start e))]
[_
(raise-mismatch-error (who) 'top p)]))
(define/override (explicate-tail label e)
(match e
[`(if ,e0 ,e1 ,e2)
(define then (fresh 'block))
(define else (fresh 'block))
(append
(explicate-pred label e0
`(goto ,then)
`(goto ,else))
(explicate-tail then e1)
(explicate-tail else e2))]
[_
(super explicate-tail label e)]))
(define/override (explicate-assign label e v t)
(match e
[`(if ,e0 ,e1 ,e2)
(define body (fresh 'block))
(define then (fresh 'block))
(define else (fresh 'block))
(append (explicate-pred label e0 `(goto ,then) `(goto ,else))
(explicate-assign then e1 v `(goto ,body))
(explicate-assign else e2 v `(goto ,body))
(list (cons body t)))]
[_
(super explicate-assign label e v t)]))
(define/public (explicate-pred label e0 g0 g1)
(match e0
[#t (list (cons label g0))]
[#f (list (cons label g1))]
;; FIXME eq?
[`(not ,a)
(explicate-pred label a g1 g0)]
[(or (? atom?) (? prim?))
(list (cons label `(if ,e0 ,g0 ,g1)))]
[`(let ([,x ,e1]) ,e2)
(define l (fresh 'block))
(append (explicate-assign label e1 x `(goto ,l))
(explicate-pred l e2 g0 g1))]
[`(if #t ,e1 ,_)
(explicate-pred label e1 g0 g1)]
[`(if #f ,_ ,e2)
(explicate-pred label e2 g0 g1)]
[`(if ,e1 ,e2 ,e3)
(define then2 (fresh 'block))
(define else2 (fresh 'block))
(append (explicate-pred label e1 `(goto ,then2) `(goto ,else2))
(explicate-pred then2 e2 g0 g1)
(explicate-pred else2 e3 g0 g1))]))
(define/override (atom? a)
(match a
[(? boolean?) #t]
[_ (super atom? a)]))
(define/override (prim? e)
(match e
[(or `(eq? ,a* ...)
`(not ,a* ...)
`(< ,a* ...))
#:when (andmap (lambda (a) (atom? a)) a*)
#t]
[_ (super prim? e)]))))
| false |
ca04d0c8c48cf5dda41e9197af9f9ee0d315aaec | 804e0b7ef83b4fd12899ba472efc823a286ca52d | /peer/src/net/scurl/impl/scurl-gui.rkt | 465da7d24d1be7edff22de3af1851268d170fdc6 | []
| no_license | cha63506/CRESTaceans | 6ec436d1bcb0256e17499ea9eccd5c034e9158bf | a0d24fd3e93fc39eaf25a0b5df90ce1c4a96ec9b | refs/heads/master | 2017-05-06T16:59:57.189426 | 2013-10-17T15:22:35 | 2013-10-17T15:22:35 | null | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 3,017 | rkt | scurl-gui.rkt | #lang scheme/gui
;;==========================================================================
;;=== Code generated with MrEd Designer 3.7 ===
;;=== http://mred-designer.origo.ethz.ch ===
;;==========================================================================
;;; Call (scurl-impl-init) with optional arguments to this module
(require
framework
)
(provide scurl-impl-init main-frame mainTab)
(define (label-bitmap-proc l)
(let ((label (first l)) (image? (second l)) (file (third l)))
(or (and image? (or (and file (let ((bmp (make-object bitmap% file 'unknown/mask))) (and (send bmp ok?) bmp))) "<Bad Image>")) label)))
(define (list->font l)
(with-handlers
((exn:fail? (λ (e) (send/apply the-font-list find-or-create-font (cons (first l) (rest (rest l)))))))
(send/apply the-font-list find-or-create-font l)))
(define scurl-impl #f)
(define main-frame #f)
(define mainTab #f)
(define control-tab #f)
(define (scurl-impl-init
#:main-frame-label
(main-frame-label "SCURL Test")
#:main-frame-width
(main-frame-width 800)
#:main-frame-height
(main-frame-height 500)
#:control-tab-label
(control-tab-label "Controls"))
(set! main-frame
(new
frame%
(parent scurl-impl)
(label main-frame-label)
(width main-frame-width)
(height main-frame-height)
(x #f)
(y #f)
(style '())
(enabled #t)
(border 0)
(spacing 0)
(alignment (list 'center 'top))
(min-width 70)
(min-height 30)
(stretchable-width #t)
(stretchable-height #t)))
(set! mainTab
(new
(class tab-panel%
(super-new)
(define single-panel (new panel:single% (parent this)))
(define/public (get-single-panel) single-panel)
(define child-panels '())
(define/public (add-child-panel p label) (set! child-panels (append child-panels (list p))) (send this append label))
(define/public (active-child n) (send single-panel active-child (list-ref child-panels n))))
(parent main-frame)
(choices (list))
(callback (λ (tp e) (send tp active-child (send tp get-selection))))
(style '())
(enabled #t)
(vert-margin 0)
(horiz-margin 0)
(border 0)
(spacing 0)
(alignment (list 'center 'center))
(min-width 0)
(min-height 0)
(stretchable-width #t)
(stretchable-height #t)))
(set! control-tab
(new
(class vertical-panel%
(init parent)
(init-field label)
(super-new (parent (send parent get-single-panel)))
(send parent add-child-panel this label))
(parent mainTab)
(label control-tab-label)
(style '())
(enabled #t)
(vert-margin 0)
(horiz-margin 0)
(border 0)
(spacing 0)
(alignment (list 'left 'center))
(min-width 0)
(min-height 0)
(stretchable-width #t)
(stretchable-height #t)))
(send main-frame show #t))
| false |
f4fd0e912ef214664dbe849378c4c68ebd5e3961 | fc22bffe6fd01f0045ade778d3ea534acb6f9e48 | /chapter01/Exercise 1.37.rkt | 263a2f375febbb3d5aa448b3961b1fb96aef200a | []
| no_license | HuTongsama/sicp | 0cd9eafed8bb03e71b4e005ff4382629fc63894f | ba722200ebc81e6fe2fd6d4c47893f36420c0f2e | refs/heads/master | 2021-07-23T06:05:01.884911 | 2020-05-06T15:26:47 | 2020-05-06T15:26:47 | 159,015,398 | 0 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 558 | rkt | Exercise 1.37.rkt | #lang sicp
(define (cont-frac n d k)
(define (next x)
(if (> x k)
(/ (n k) (d k))
(/ (n k)
(+ (d k) (next (+ x 1))))))
(next 1))
(define (cont-frac-iter n d k)
(define (cal x result)
(/ (n x)
(+ (d x) result)))
(define (iter count result)
(if (< count 1)
result
(iter (- count 1)
(cal count result))))
(iter k 0))
(cont-frac (lambda (i) 1.0)
(lambda (i) 1.0)
100)
(cont-frac-iter (lambda (i) 1.0)
(lambda (i) 1.0)
100) | false |
8754709d1aee4871b6d25a6e5c98e72f07a6a72b | f05faa71d7fef7301d30fb8c752f726c8b8c77d4 | /src/exercises/ex-3.35.rkt | 8df8392cc308c0d2436e86f0e6132840e160374d | []
| no_license | yamad/sicp | c9e8a53799f0ca6f02b47acd23189b2ca91fe419 | 11e3a59f41ed411814411e80f17606e49ba1545a | refs/heads/master | 2021-01-21T09:53:44.834639 | 2017-02-27T19:32:23 | 2017-02-27T19:32:23 | 83,348,438 | 1 | 0 | null | null | null | null | UTF-8 | Racket | false | false | 1,264 | rkt | ex-3.35.rkt | #lang racket
;; Exercise 3.35 -- Ben Bitdiddle tells Louis that one way to avoid
;; the trouble in Exercise 3.34 is to define a squarer as a new
;; primitive constraint. Fill in the missing portions in Ben’s outline
;; for a procedure to implement such a constraint:
(require "../examples/constraints.rkt")
(define (squarer a b)
(define (process-new-value)
(cond ((has-value? b)
(if (< (get-value b) 0)
(error "square less than 0: SQUARER"
(get-value b))
(set-value! a (sqrt (get-value b)) me)))
((has-value? a)
(set-value! b (* (get-value a)
(get-value a)) me))))
(define (process-forget-value)
(forget-value! b me)
(forget-value! a me)
(process-new-value))
(define (me request)
(cond ((eq? request 'I-have-a-value)
(process-new-value))
((eq? request 'I-lost-my-value)
(process-forget-value))
(else
(error "Unknown request -- SQUARER" request))))
(connect a me)
(connect b me)
me)
;; tests
(define a (make-connector))
(define b (make-connector))
(probe "A" a)
(probe "B" b)
(squarer a b)
(set-value! a 2 'user)
(forget-value! a 'user)
(set-value! b 9 'user)
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.