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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ac41b3d78025f4a30ff7b3931107b4f7f72d166b
|
bffa778b60a2cf354be83cc4488d6e1448c10b1a
|
/readerM-multi.ss
|
777c7a3df07d500cfb99e4e428090b7f951633e4
|
[] |
no_license
|
localchart/scheme-monads
|
733cb5833da0c4e6699aa6c5e90fe5731e3bc663
|
a027034554e822521102aaacbf6135461c73299f
|
refs/heads/master
| 2020-12-28T20:42:36.940467 | 2012-05-16T19:18:17 | 2012-05-16T19:18:17 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 882 |
ss
|
readerM-multi.ss
|
(library (monad readerM-multi)
(export ask-for
local-for
with-new-env)
(import (chezscheme)
(monad core)
(monad readerM)
(monad aux))
; env has form ((t0 . env0) (t1 . env1) ...)
; where t0, t1, ... are tags for their environments
; and t0, t, ... are all unique
; and env0, env1, ... are alists
; accessor for tagged environment
(define ask-for
(lambda (t)
(lambda ()
(lambda (e)
(cond
((assq t e) => cdr)
(else #f))))))
; local modification of tagged environment
(define local-for
(lambda (t)
(lambda (f m)
(local-reader
(mod-in-list t f)
m))))
; introduce new tagged environment in inner computation
(define with-new-env
(lambda (t/e m)
(local-reader
(lambda (e) `(,t/e . ,e))
m)))
)
| false |
f0d6eacfb2e1444a43b76519d63f5f7dd42a4819
|
eef5f68873f7d5658c7c500846ce7752a6f45f69
|
/spheres/gambit/ffi/c-define-base-macros#.scm
|
2a83143e3ad06ffd4b3f7a78970ac9da59a54a23
|
[
"MIT"
] |
permissive
|
alvatar/spheres
|
c0601a157ddce270c06b7b58473b20b7417a08d9
|
568836f234a469ef70c69f4a2d9b56d41c3fc5bd
|
refs/heads/master
| 2021-06-01T15:59:32.277602 | 2021-03-18T21:21:43 | 2021-03-18T21:21:43 | 25,094,121 | 13 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 17,383 |
scm
|
c-define-base-macros#.scm
|
;;!!! Simple FFI generation macros
;; .author Álvaro Castro Castilla, 2013-2015. All Rights Reserved.
;;------------------------------------------------------------------------------
;;!! Old stuff to keep in mind
;; This nasty hack substitutes the '() for ()
;; It turns out that Gambit uses () for argument lists, which is not an acceptable
;; syntax for most syntax-rules expanders
;; (define-macro (c-lambda . body)
;; `(##c-lambda ,@(map (lambda (f) (if (and (pair? f)
;; (pair? (cdr f))
;; (eq? (cadr f) '()))
;; '()
;; f))
;; body)))
;; ;; The same for c-define
;; (define-macro (c-define . body)
;; `(##c-define ,@(map (lambda (f) (if (and (pair? f)
;; (pair? (cdr f))
;; (eq? (cadr f) '()))
;; '()
;; f))
;; body)))
;;------------------------------------------------------------------------------
;;!! Prelude
(define-macro (eval-in-macro-environment . exprs)
(eval (if (null? (cdr exprs)) (car exprs) (cons 'begin exprs))
(interaction-environment)))
(define-macro (define^ . args)
`(eval-in-macro-environment
(define ,(car args) ,@(cdr args))))
;;------------------------------------------------------------------------------
;;!! Macro utils
(define^ (%%get-key-arg args key default)
(if (null? args)
default
(let ((found (memq key args)))
(if (and found
(not (null? (cdr found))))
(cadr found)
default))))
;; Build a string from list of elements (anything)
(define^ (%%generic-string-append . ol)
(define (->string o)
(cond ((string? o) o)
((symbol? o) (symbol->string o))
((keyword? o) (keyword->string o))
(else (error (string-append "c-define-array :: ->string: undesirable type -- "
(object->string o))))))
(apply string-append (map ->string ol)))
;; Append anything into a symbol
(define^ (%%generic-symbol-append . ol)
(string->symbol (apply %%generic-string-append ol)))
;; Turn a scheme-name into a c_name, simply changing the - to _
(define^ (%%scheme-name->c-name name)
(let* ((name-str (cond ((string? name) name)
((symbol? name) (symbol->string name))
(else (object->string name))))
(new-name (string-copy name-str))
(name-length (string-length new-name)))
(let recur ((i 0))
(if (< i name-length)
(begin (if (char=? (string-ref new-name i) #\-)
(string-set! new-name i #\_))
(recur (+ i 1)))
new-name))))
;;! Schemify a name: turn-it-into-a-scheme-name
;; .author Fred LeMaster
(define^ (%%c-name->scheme-name symbol-or-string)
((lambda (str)
(letrec
((str-length (string-length str))
(case-changed?
(lambda (i)
(let ((h (- i 1)))
(cond ((< h 0) #f)
((and (char-lower-case? (string-ref str h))
(char-upper-case? (string-ref str i)))
#t)
(else #f)))))
(char-loop
(lambda (i out)
(cond ((>= i str-length) out)
((char=? (string-ref str i) #\_)
(char-loop (+ i 1) (cons #\- out)))
((and (char=? (string-ref str i) #\:)
(< (+ i 1) str-length)
(char=? (string-ref str (+ i 1)) #\:))
(char-loop (+ i 2) (cons #\- out)))
((case-changed? i)
(char-loop (+ i 1)
(cons (char-downcase
(string-ref str i))
(cons #\-
out))))
(else (char-loop (+ i 1)
(cons
(char-downcase
(string-ref str i))
out)))))))
(list->string (reverse (char-loop 0 '())))))
(cond ((symbol? symbol-or-string) (symbol->string symbol-or-string))
((string? symbol-or-string) symbol-or-string)
(else (error "%%c-name->scheme-name: expected symbol or string")))))
;; Generate a list of top-level forms
(define^ (%%begin-top-level-forms #!rest define-blocks)
(cons 'begin
(let recur ((ds define-blocks))
(cond ((null? ds) '())
((null? (car ds)) (recur (cdr ds)))
(else (cons (car ds)
(recur (cdr ds))))))))
;;------------------------------------------------------------------------------
;;!! FFI generation
;;! C constants generation macro
;; Creating the bindings in a simple C function makes for more compact
;; https://mercure.iro.umontreal.ca/pipermail/gambit-list/2012-February/005688.html
(define-macro (c-define-constants . names)
(let ((nb-names (length names))
(wrapper (gensym)))
(letrec ((interval (lambda (lo hi)
(if (< lo hi) (cons lo (interval (+ lo 1) hi)) '()))))
`(begin
(##define ,wrapper
(c-lambda (int)
int
,(string-append
"static int _tmp_[] = {\n"
(apply string-append
(map (lambda (i name)
(let ((name-str (symbol->string name)))
(string-append
(if (> i 0) "," "")
name-str)))
(interval 0 nb-names)
names))
"};\n"
"___result = _tmp_[___arg1];\n")))
,@(map (lambda (i name)
`(##define ,name (,wrapper ,i)))
(interval 0 nb-names)
names)))))
;;! Build a size-of value equivalent to the C operator
;; c-build-sizeof float -> sizeof-float
(define-macro (c-define-sizeof scheme-type . rest)
(let ((c-type (%%get-key-arg rest c-type: (symbol->string scheme-type))))
`(define ,(string->symbol (string-append (symbol->string scheme-type) "-size"))
((c-lambda () size-t
,(string-append "___result = sizeof(" c-type ");"))))))
;;! Build FFI procedures for C type arrays. Only for use with basic types, not structs.
;; (c-define-array float f32) ->
;; alloc-float*
;; float*-ref
;; float*-set!
;; *->float*
;; f32vector->float*
(define-macro (c-define-array scheme-type . rest)
(let ((c-type (%%get-key-arg rest c-type: scheme-type))
(scheme-vector (%%get-key-arg rest scheme-vector: #f)))
(if (not scheme-vector) (error "c-define-array macro :: scheme-vector: argument is mandatory"))
(let ((release-type-str (string-append "___release_" (%%scheme-name->c-name scheme-type)))
(type scheme-type)
(type*
(%%generic-symbol-append scheme-type "*"))
(type*/nonnull
(%%generic-symbol-append scheme-type "*/nonnull"))
(type*/release-rc
(%%generic-symbol-append scheme-type "*/release-rc")))
(let ((expansion
(%%begin-top-level-forms
`(c-declare
,(string-append
"static ___SCMOBJ " release-type-str "( void* ptr )\n"
"{\n"
;; " printf(\"GC called free()!\\n\");\n"
;; " ___EXT(___release_rc)( ptr );\n"
" free( ptr );\n"
" return ___FIX(___NO_ERR);\n"
"}\n"))
;; Alloc managed by Gambit's GC
`(define ,(%%generic-symbol-append 'alloc- scheme-type '*/unmanaged)
(c-lambda (size-t)
,type*/nonnull
,(%%generic-string-append "___result_voidstar = malloc(___arg1*sizeof(" c-type "));")))
;; Alloc unmanaged by Gambit's GC
`(define ,(%%generic-symbol-append 'alloc- scheme-type '*)
(c-lambda (size-t)
,type*/release-rc
;; ,(%%generic-string-append "___result_voidstar = ___EXT(___alloc_rc)(___arg1*sizeof(" c-type "));")
,(%%generic-string-append "___result_voidstar = malloc(___arg1*sizeof(" c-type "));")))
`(define ,(%%generic-symbol-append scheme-type '*-ref)
(c-lambda (,type*/nonnull size-t)
,scheme-type
"___result = ___arg1[___arg2];"))
`(define ,(%%generic-symbol-append scheme-type '*-set!)
(c-lambda (,type*/nonnull size-t ,scheme-type)
void
"___arg1[___arg2] = ___arg3;"))
`(define ,(%%generic-symbol-append '*-> scheme-type)
(c-lambda (,type*/nonnull)
,scheme-type
"___result = *___arg1;"))
(if scheme-vector
`(define (,(%%generic-symbol-append scheme-vector 'vector-> scheme-type '*) vec)
(let* ((length (,(%%generic-symbol-append scheme-vector 'vector-length) vec))
(buf (,(%%generic-symbol-append 'alloc- scheme-type '*) length)))
(let loop ((i 0))
(if (fx< i length)
(begin
(,(%%generic-symbol-append scheme-type '*-set!) buf i (,(%%generic-symbol-append scheme-vector 'vector-ref) vec i))
(loop (fx+ i 1)))
buf))))
'()))))
(if #f ;; #t for debugging
(pp `(definition:
(c-define-array scheme-type: ,scheme-type c-type: ,c-type scheme-vector: ,scheme-vector)
expansion:
,expansion)))
expansion))))
;;------------------------------------------------------------------------------
;;!! FFI generation
;;! define types for structs, unions and arrays
;; .author Álvaro Castro-Castilla, based on code by Estevo Castro
;; (c-define-type* (struct MyStruct))
;; (c-define-type* (union MyUnion))
;; (c-define-type* myType)
(define-macro (c-define-type* type/struct/union)
(let* ((type (if (pair? type/struct/union)
(cadr type/struct/union)
type/struct/union))
(struct-or-union (if (pair? type/struct/union)
(car type/struct/union)
#f))
(type-str (symbol->string type))
(release-type-str (string-append "___release_" (%%scheme-name->c-name type-str)))
(type* (%%generic-symbol-append type-str "*"))
(type*/nonnull (%%generic-symbol-append type-str "*/nonnull"))
(type*/release-rc (%%generic-symbol-append type-str "*/release-rc")))
(let ((expansion
(%%begin-top-level-forms
(if struct-or-union
`(c-define-type ,type (,struct-or-union ,type-str))
'())
`(c-define-type ,type* (pointer ,type (,type*)))
`(c-define-type ,type*/nonnull (nonnull-pointer ,type (,type*)))
`(c-define-type ,type*/release-rc (nonnull-pointer ,type (,type*) ,release-type-str)))))
(if #f ;; #t for debugging
(pp `(definition:
(c-define-extended-type ,type)
expansion:
,expansion)))
expansion)))
;; Helper for define-c-struct and define-c-union
(define^ (%%c-define-struct-or-union struct-or-union type fields)
(let* ((type-str (symbol->string type))
(struct-type-str (string-append
(case struct-or-union
((struct) "struct ")
((union) "union ")
(else
(error "%%c-define-struct-or-union: first parameter must be 'struct or 'union")))
type-str))
(struct-type*-str (string-append struct-type-str "*"))
(release-type-str (string-append "___release_" type-str))
(type* (%%generic-symbol-append type-str "*"))
(type*/nonnull (%%generic-symbol-append type-str "*/nonnull"))
(type*/release-rc (%%generic-symbol-append type-str "*/release-rc")))
(define (field-getter-setter field-spec)
(let* ((field (car field-spec))
(field-str (symbol->string field))
(field-description (cadr field-spec)))
(if (pair? field-description)
;; Field is either a 'struct', an 'array' or an 'array of structs'
(let* ((field-tag (car field-description))
(field-type (cadr field-description))
(field-type-str (symbol->string field-type)))
(case field-tag
;; Struct
((struct)
`((define ,(%%generic-symbol-append type-str "-" field-str)
(c-lambda (,type*/nonnull)
,(%%generic-symbol-append field-type-str "*/nonnull")
,(string-append "___result_voidstar = &___arg1->" field-str ";")))
(define ,(%%generic-symbol-append type-str "-" field-str "-set!")
(c-lambda (,type*/nonnull ,field-type)
void
,(string-append "___arg1->" field-str " = ___arg2;")))))
;; Array of fundamental type
((array)
;; generate a getter and a setter
`((define ,(%%generic-symbol-append type-str "-" field-str "-ref")
(c-lambda (,type*/nonnull int)
,field-type
,(string-append "___result = ___arg1->" field-str "[___arg2];")))
(define ,(%%generic-symbol-append type-str "-" field-str "-set!")
(c-lambda (,type*/nonnull int ,field-type)
void
,(string-append "___arg1->" field-str "[___arg2] = ___arg3;")))))
;; Array of structs
((struct-array)
;; only generate a getter returning struct address
`((define ,(%%generic-symbol-append type-str "-" field-str "-ref")
(c-lambda (,type*/nonnull int)
,(%%generic-symbol-append field-type-str "*/nonnull")
,(string-append "___result_voidstar = &___arg1->" field-str "[___arg2];")))))))
;; Field is fundamental type
`((define ,(%%generic-symbol-append type-str "-" field-str)
(c-lambda (,type*/nonnull)
,field-description
,(string-append "___result = ___arg1->" field-str ";")))
(define ,(%%generic-symbol-append type-str "-" field-str "-set!")
(c-lambda (,type*/nonnull ,field-description)
void
,(string-append "___arg1->" field-str " = ___arg2;")))))))
(let ((expansion
`(begin
;; Define the release function which is called when the
;; object is no longer accessible from the Scheme world.
(c-declare
,(string-append
"static ___SCMOBJ " release-type-str "( void* ptr )\n"
"{\n"
" ___EXT(___release_rc)( ptr );\n"
" return ___FIX(___NO_ERR);\n"
"}\n"))
;; Define type allocator procedure.
(define ,(%%generic-symbol-append "alloc-" type-str)
(c-lambda ()
,type*/release-rc
,(string-append "___result_voidstar = ___EXT(___alloc_rc)( sizeof( " struct-type-str " ) );")))
;; Dereference
(define ,(%%generic-symbol-append "*->" type-str)
(c-lambda (,type*/nonnull)
,type
,(string-append "___result_voidstar = (" type-str "*)___arg1;")))
;; Define field getters and setters.
,@(apply append (map field-getter-setter fields)))))
(if #f ;; #t for debugging
(pp `(definition:
(c-define-struct ,type ,@fields)
expansion:
,expansion)))
expansion)))
;;! Defines the c-define-struct macro, which extends the Gambit FFI to
;; interface to C structures.
(define-macro (c-define-struct type . fields)
(%%c-define-struct-or-union 'struct type fields))
;;! Defines the c-define-union macro, which extends the Gambit FFI to
;; interface to C structures.
(define-macro (c-define-union type . fields)
(%%c-define-struct-or-union 'union type fields))
| false |
898858d177cafcb866b3161e06c9ee80b238ab1a
|
ecfd9ed1908bdc4b099f034b121f6e1fff7d7e22
|
/compiler/P423/lib/driver.ss
|
21ca583059800c4e4d84828ff80e12c6d6faf263
|
[
"MIT"
] |
permissive
|
sKabYY/palestra
|
36d36fc3a03e69b411cba0bc2336c43b3550841c
|
06587df3c4d51961d928bd8dd64810c9da56abf4
|
refs/heads/master
| 2021-12-14T04:45:20.661697 | 2021-11-25T08:29:30 | 2021-11-25T08:29:30 | 12,856,067 | 6 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 26,868 |
ss
|
driver.ss
|
;;; driver.ss
;;; Copyright (c) 2001-2009 R. Kent Dybvig, Oscar Waddell, and Daniel P. Friedman
;;; This file contains driver code for running p423 compilers through
;;; their paces.
;;; Overview:
;;;
;;; The driver runs each pass of the compiler and tests its output to
;;; make sure it returns the same answer as the source program. It can
;;; test one test at a time or all of the tests in a list of tests.
;;; Basic Usage:
;;;
;;; To use the driver for Assignment 1, create a file containing:
;;;
;;; (eval-when (compile load eval)
;;; (optimize-level 2)
;;; (case-sensitive #t)
;;; )
;;;
;;; (load "match.ss")
;;; (load "helpers.ss")
;;; (load "fmts.pretty") ; inform pretty-print about new forms
;;; (load "driver.ss")
;;;
;;; (load "a1.ss")
;;; (load "a1-wrapper.ss") ; defines syntactic forms and procedures
;;; ; needed to output of each pass
;;; (compiler-passes '(
;;; verify-scheme
;;; generate-x86-64
;;; ))
;;;
;;; (load "tests1.ss")
;;;
;;; Load this into Chez Scheme, and type (test-all) to run all of the
;;; valid tests, or (test-all-invalid) to run all of the invalid tests.
;;; Use test-one or test-one-invalid to run an individual test.
;;;
;;; To use the driver for later assignments, change the last several
;;; lines to include the appropriate files and list the current passes.
;;; Detailed description of the driver routines:
;;; (compiler-passes '(<spec> ...))
;;; Tells the driver which compiler passes to run. This should be
;;; set once at the top of the file containing your compiler. <spec>
;;; may be one of the following:
;;;
;;; pass-name
;;; run the pass named by pass-name. Each pass is fed the output
;;; of the preceding pass, except the first, which is fed the
;;; original input.
;;;
;;; (iterate <spec> ...)
;;; run <spec> ... repeatedly
;;;
;;; (break when predicate?)
;;; break out of an iteration, or if not in an iteration, exit
;;; from the driver, if predicate? returns true when passed the
;;; the output of the pass just run.
;;;
;;; (break unless predicate?)
;;; break out of an iteration, or if not in an iteration, exit
;;; from the driver, if predicate? returns false when passed the
;;; the output of the pass just run.
;;;
;;; Example:
;;; (compiler-passes '(a (iterate b (break when c?) d) e))
;;; runs a on the input and feeds its output to b. If c? applied
;;; to the output of b is true, feeds the output of b to e;
;;; otherwise, feeds the output of b to d and the output of d to
;;; b, then tests c? on the output of b again, and so on.
;;; (language-wrapper procedure)
;;; Tells the driver a procedure it should call to wrap each expression
;;; before evaluation. Defaults to the procedure value of:
;;; (lambda (x) `(let () (import scheme) ,x))
;;; (test-one-invalid '<program>)
;;; (test-one-invalid '<program> <verbose?>)
;;; Runs the first pass of the compiler, assumed to be a verifier,
;;; displays the error message it produces or, if it doesn't signal
;;; an error, raises one of its own to indicate failure.
;;;
;;; If <verbose?> is false, less diagnostic information is printed.
;;; <verbose?> defaults to #t.
;;; (test-all-invalid)
;;; (test-all-invalid <verbose?>)
;;; Runs test-one-invalid in order on the tests in the list bound
;;; to the variable invalid-tests, stopping if any test fails. Usually
;;; used with tests.ss loaded.
;;;
;;; If <verbose?> is false, less diagnostic information is printed.
;;; <verbose?> defaults to #t.
;;; (test-last-invalid)
;;; (test-last-invalid <verbose?>)
;;; Like test-one-invalid, except <program> is the last input to
;;; test-one-invalid or the last test run by test-all-invalid.
;;;
;;; If <verbose?> is false, less diagnostic information is printed.
;;; <verbose?> defaults to #t.
;;; (test-one '<program>)
;;; (test-one '<program> <emit?>)
;;; (test-one '<program> <emit?> <verbose?>)
;;; Compile and test <program>. test-one first computes the correct
;;; answer by evaluting it with Chez Scheme's interpreter. It then
;;; passes the program to the first pass, evalutes the resulting
;;; program, and compares the value with the correct answer. If it
;;; compares equal?, it goes on to the next pass, passing it the
;;; program returned by the first. It repeats this process until
;;; all passes have been run, then exits.
;;;
;;; If a pass is a code-generation pass (generate-C-code or
;;; generate-Sparc-code), its output is compiled or assembled, linked
;;; with the run-time code in startup.c, and run. The output is read
;;; back in and compared with the correct answer. The next pass, if
;;; any, is run on the output of the preceding pass.
;;;
;;; If the result of evaluating the program returned by any of the
;;; passes does not equal the correct answer or if the evaluation
;;; causes an error, test-one stops, prints the input to the pass,
;;; prints the output to the pass, and displays the error message.
;;; If a problem occurs while running a pass, test-one stops, prints
;;; the input to the pass, and displays the error message.
;;;
;;; If <emit?> is false, test-one doesn't build or run the code
;;; generated by the code generation pass(es). This is useful when
;;; trying to test changes to earlier parts of the compiler, since
;;; the process of building an executable file and running it is
;;; rather slow. <emit?> defaults to #t.
;;;
;;; If <verbose?> is false, less diagnostic information is printed.
;;; <verbose?> defaults to #t.
;;; (test-all)
;;; (test-all <emit?>)
;;; (test-all <emit?> <verbose?>)
;;; Runs test-one in order on the tests in the list bound to the
;;; variable tests, stopping if any test fails. Usually used with
;;; tests.ss loaded. If <verbose?> is true, test-all prints each
;;; test before it is compiled and run. Passes <emit?> and <verbose?>
;;; along to test-one. <emit?> and <verbose?> both default to #t.
;;; (test-last)
;;; (test-last <emit?>)
;;; (test-last <emit?> <verbose?>)
;;; Like test-one, except <program> is the last input to test-one
;;; or the last test run by test-all or analyze-all.
;;; (analyze-all)
;;; (analyze-all <emit?>)
;;; Runs test-one in order on the tests in the list bound to the
;;; variable tests. Does not stop for when a test fails. Usually
;;; used with tests.ss loaded. Passes <emit?> along to test-one,
;;; with <verbose?> false. <emit?> defaults to #t. Prints a "." for
;;; each test before running it, but doesn't print the test itself.
;;; Prints a summary after all tests have been run.
;;; (tracer #t)
;;; Causes test-one to print the output of each pass.
;;;
;;; (tracer '<pass-name>)
;;; Causes test-one to print only the output of the specified
;;; pass.
;;;
;;; (tracer '(<pass-name> ...))
;;; Causes test-one to print only the output of the specified
;;; passes. (tracer '()) or (tracer #f) disables tracing.
;;; (suppress-language-definition #t)
;;; Causes the language definition part of an intermediate language
;;; program to be omitted from tracer output, i.e., if the output
;;; appears as (let () (begin <definitions> ...) expr), only expr
;;; is printed.
;;;
;;; (suppress-language-definition #f)
;;; Disables suppression of the language definition.
;;; (starting-pass '<pass-name>)
;;; Causes driver to start running each test from (first run of)
;;; <pass-name>. Usually used with test-one, but can be used with
;;; test-all and analyze-all if the variable tests is bound to a
;;; list of valid inputs to <pass-name>. also respected by
;;; test-last.
;;;
;;; (starting-pass #f)
;;; Resets starting pass to original first pass.
;;; (game-eval)
;;; (game-eval <proc>)
;;; game-eval is a parameter that determines the evaluator used to
;;; evaluate the output of each nongenerator pass. When called without
;;; arguments, it returns the current game evaluator. When called
;;; with one argument, <proc>, it sets the game evaluator to <proc>.
;;; The initial game evaluator is interpret, which provides quick
;;; turnaround for small test cases. Set it to compile to get better
;;; error messages and inspector information.
;;; (print-file '<pathname>)
;;; Prints the contents of the file specified by <pathname> to the
;;; current output port.
;;; (trusted-passes)
;;; (trusted-passes '(<pass-name> ...))
;;; Without arguments, returns a list naming the trusted passes, i.e.,
;;; those whose output is not to be compared against the original input.
;;; Otherwise, sets the list of trusted passes. (trusted-passes #t)
;;; is short-hand for trusting all passes, and (trusted-passes #f)
;;; has the same effect as (trusted-passes '()).
;;; (check-final-output-only)
;;; (check-final-output-only <boolean>)
;;; check-final-output is a parameter. If set to true, the value
;;; of the final output of the compiler is compared against the value
;;; of the original input, and the normal checking of each intermediate
;;; program is suppressed, i.e., all passes are considered trusted.
;;; (timed-passes)
;;; (timed-passes '(<pass-name> ...))
;;; Without arguments, returns a list naming the timed passes, i.e.,
;;; those for which compile times are displayed. Otherwise, sets the
;;; list of timed passes. (timed-passes #t) is short-hand for timing
;;; all passes, and (timed-passes #f) has the same effect as
;;; (trusted-passes '()).
(module (language-wrapper tracer suppress-language-definition game-eval analyze-all
$analyze test-all test-one test-last trusted-passes print-file
starting-pass compiler-passes timed-passes check-final-output-only
test-one-invalid test-last-invalid test-all-invalid)
(define test-ordinal #f)
(import scheme)
(define compiler-passes
(let ([passes #f])
(case-lambda
[() (or passes
; backward compatibility:
(if (top-level-bound? 'pass-names)
(let ([p pass-names])
(unless (valid-passes? p)
(error 'pass-names "invalid pass-names value ~s" p))
p)
'()))]
[(p)
(unless (valid-passes? p)
(error 'compiler-passes "invalid pass list ~s" p))
(set! passes p)])))
(define valid-passes?
(lambda (p)
(define ipass?
(lambda (p)
(match p
[(break when ,pred) (guard (symbol? pred)) #t]
[(break unless ,pred) (guard (symbol? pred)) #t]
[,p (pass? p)])))
(define pass?
(lambda (p)
(match p
[(iterate ,p ...) (andmap ipass? `(,@p))]
[,p (guard (symbol? p)) #t]
[,p #f])))
(match p
[(,p ...) (andmap pass? `(,@p))]
[,p #f])))
(define all-pass-names
(lambda ()
(define ipass
(lambda (p)
(match p
[(break when ,pred) (guard (symbol? pred)) '()]
[(break unless ,pred) (guard (symbol? pred)) '()]
[,p (pass p)])))
(define pass
(lambda (p)
(match p
[(iterate ,[ipass -> p*] ...) (apply append p*)]
[,p (guard (symbol? p)) (list p)]
[,p #f])))
(match (compiler-passes)
[(,[pass -> p*] ...) (apply append p*)])))
(define language-wrapper
(make-parameter (lambda (x) `(let () (import scheme) ,x))
(lambda (x)
(unless (procedure? x)
(error 'language-wrapper "~s is not a procedure" x))
x)))
(define suppress-language-definition (make-parameter #f))
(define tracer-print
(lambda (x)
(pretty-print
(if (suppress-language-definition)
(match x
[(let () ,ld ,x) `(let () <lang-defn> ,x)]
[(let () ,ld ,gd ,x) `(let () <lang-defn> ,gd ,x)]
[,x x])
x))))
(define tracer
(let ([trace-list '()])
(case-lambda
[() trace-list]
[(x)
(set! trace-list
(cond
[(eq? x #t) (all-pass-names)]
[(eq? x #f) '()]
[(and (symbol? x) (memq x (all-pass-names))) (list x)]
[(and (list? x) (andmap (lambda (x) (memq x (all-pass-names))) x)) x]
[else (error 'tracer "invalid argument ~s" x)]))])))
(define timed-passes
(make-parameter
'()
(lambda (x)
(cond
[(eq? x #t) (all-pass-names)]
[(eq? x #f) '()]
[(and (list? x) (andmap (lambda (x) (memq x (all-pass-names))) x)) x]
[else (error 'timed-passes "invalid pass names ~s"
(if (list? x) (difference x (all-pass-names)) x))]))))
(define trusted-passes
(make-parameter
'()
(lambda (x)
(cond
[(eq? x #t) (all-pass-names)]
[(eq? x #f) '()]
[(and (list? x) (andmap (lambda (x) (memq x (all-pass-names))) x)) x]
[else (error 'trusted-passes "invalid pass names ~s"
(if (list? x) (difference x (all-pass-names)) x))]))))
(define check-final-output-only (make-parameter #f))
(define game-eval
(make-parameter interpret
(lambda (x)
(unless (procedure? x)
(error 'game-eval "~s is not a procedure" x))
x)))
(define starting-pass
(make-parameter #f
(lambda (p)
(unless (or (not p) (memq p (all-pass-names)))
(error 'starting-pass "unrecognized pass ~s" p))
p)))
(define analyze-all
(case-lambda
[() (analyze-all #t)]
[(emit?)
(let-values ([(passed total) ($analyze emit? #t)])
(printf "~%~s of ~s tests passed~%" passed total))]))
(define $analyze
(lambda (emit? echo?)
(define mod 72)
(let f ([tests tests] [n 0] [passed 0] [m mod])
(if (null? tests)
(values passed n)
(begin
(if (call/cc
(lambda (k)
(parameterize ([reset-handler (lambda () (k #f))])
($test-one (car tests) emit? #f n)
#t)))
(begin
(when echo?
(when (= m mod) (newline))
(write-char #\.)
(flush-output-port))
(f (cdr tests) (+ n 1) (+ passed 1) (+ (modulo m mod) 1)))
(f (cdr tests) (+ n 1) passed mod)))))))
(define test-all
(case-lambda
[() (test-all #t #t)]
[(emit?) (test-all emit? #t)]
[(emit? verbose?)
(let f ([tests tests] [n 0])
(unless (null? tests)
(when verbose?
(let ([s (format "~s: " n)])
(display s)
(parameterize ([pretty-initial-indent (string-length s)])
(pretty-print (car tests)))))
($test-one (car tests) emit? verbose? n)
(f (cdr tests) (+ n 1))))]))
(define print-file
(lambda (path)
(with-input-from-file path
(rec f
(lambda ()
(unless (eof-object? (peek-char))
(write-char (read-char))
(f)))))))
(define *last-input-expr*)
(define test-one-invalid
(case-lambda
[(expr) ($test-one-invalid expr #t #f)]
[(expr verbose?) ($test-one-invalid expr verbose? #f)]))
(define test-last-invalid
(case-lambda
[() ($test-one-invalid *last-input-expr* #t #f)]
[(verbose?) ($test-one-invalid *last-input-expr* verbose? #f)]))
(define test-all-invalid
(case-lambda
[() (test-all-invalid #t)]
[(verbose?)
(let f ([tests invalid-tests] [n 0])
(unless (null? tests)
(when verbose?
(let ([s (format "~s: " n)])
(display s)
(parameterize ([pretty-initial-indent (string-length s)])
(pretty-print (car tests)))))
($test-one-invalid (car tests) verbose? n)
(f (cdr tests) (+ n 1))))]))
(define $test-one-invalid
(lambda (expr verbose? ordinal)
(let ([verifier (car (compiler-passes))])
(set! *last-input-expr* expr)
((call/cc
(lambda (k)
(parameterize ([error-handler
(lambda (who msg . args)
(parameterize ([print-level 3] [print-length 6])
(k (lambda ()
(printf "~@[~a~]: ~?.\n"
(and who (not (eqv? who "")) who)
msg args)))))])
((eval verifier) expr)
(lambda ()
(if ordinal
(error #f "no error from ~s on test ~s" verifier ordinal)
(error #f "no error from ~s" verifier))))))))))
(define test-one
(case-lambda
[(expr) ($test-one expr #f #t #f)]
[(expr emit?) ($test-one expr emit? #t #f)]
[(expr emit? verbose?) ($test-one expr emit? verbose? #f)]))
(define test-last
(case-lambda
[() ($test-one *last-input-expr* #t #t #f)]
[(emit?) ($test-one *last-input-expr* emit? #t #f)]
[(emit? verbose?) ($test-one *last-input-expr* emit? verbose? #f)]))
;; (define fmt
;; (lambda (x n)
;; (define digit
;; (lambda (d)
;; (string-ref "000123456789" (+ d 2))))
;; (let ([x (exact->inexact x)])
;; (let ([ls (#%\#flonum->digits x 10 'absolute (- n))])
;; (let ([s (car ls)] [e (cadr ls)] [digits (cddr ls)])
;; (let ([p (open-output-string)])
;; (when (= s -1) (write-char #\- p))
;; (when (< e 0) (write-char #\0 p))
;; (when (< e -1)
;; (write-char #\. p)
;; (display (make-string (min n (- -1 e)) #\0) p))
;; (let f ([digits digits] [e e])
;; (when (>= e (- n))
;; (when (= e -1) (write-char #\. p))
;; (write-char (digit (car digits)) p)
;; (f (cdr digits) (- e 1))))
;; (get-output-string p)))))))
(define-syntax time-it
(syntax-rules ()
[(_ e1 e2 ...)
(let ([before (statistics)])
(let ([v (begin e1 e2 ...)])
(let ([elapsed (sstats-difference (statistics) before)])
(values
v
(format "~asec, ~amb"
(fmt (/ (sstats-cpu elapsed) 1000) 2)
(fmt (/ (sstats-bytes elapsed) (expt 2 20)) 2))))))]))
(define $test-one
(lambda (original-input-expr emit? verbose? ordinal)
; caution: this doesn't stop error from happening, just allows
; something to be done on the way down
(define-syntax on-error
(syntax-rules ()
[(_ e0 e1 e2 ...)
(parameterize ([error-handler
(let ([eh (error-handler)])
(lambda args
(parameterize ([current-output-port
(console-output-port)])
e0)
(apply eh args)))])
e1 e2 ...)]))
(define (eval-it pass-name x)
(reset-machine-state!)
((game-eval) ((language-wrapper) pass-name x)))
(define adjust-unc!
(lambda (x)
(unique-name-count
(let f ([x x])
(cond
[(and (symbol? x) (extract-suffix x)) => string->number]
[(pair? x) (max (f (car x)) (f (cdr x)))]
[(vector? x) (f (vector->list x))]
[else 0])))))
(adjust-unc! original-input-expr)
(set! *last-input-expr* original-input-expr)
(let ([answer (delay (eval-it 'source original-input-expr))])
(define check-eval
(lambda (pass-name input-expr output-expr)
(on-error
(when verbose?
(unless (eq? input-expr output-expr)
(printf "~%~s input:~%" pass-name)
(pretty-print input-expr))
(printf "========~%~s output:~%" pass-name)
(pretty-print output-expr))
(let ([t (parameterize ([run-cp0 (lambda (cp0 x) x)])
(on-error
(if ordinal
(printf "~%Error occurred running output of pass ~s on test ~s"
pass-name ordinal)
(printf "~%Error occurred running output of pass ~s" pass-name))
(eval-it pass-name output-expr)))])
(unless (equal? t (force answer))
(if ordinal
(error #f
"evaluating output of ~s for test ~s produces ~s, should have been ~s"
pass-name ordinal t (force answer))
(error #f
"evaluating output of ~s produces ~s, should have been ~s"
pass-name t (force answer))))))))
(define check-build-eval
(lambda (pass-name input-expr output-string)
(on-error
(begin
(if ordinal
(printf "~%Error occurred while running code generated by ~s for test ~s~%"
pass-name ordinal)
(printf "~%Error occurred while running code generated by ~s~%"
pass-name))
(when verbose?
(printf "~s input:~%" pass-name)
(pretty-print input-expr)
(printf "========~%~s output:~%" pass-name)
(display-string output-string)))
(let ([t (build-and-run input-expr output-string)])
(unless (equal? t (force answer))
(if ordinal
(error #f
"evaluating output of ~s for test ~s produces ~s, should have been ~s"
pass-name ordinal t (force answer))
(error #f
"evaluating output of ~s produces ~s, should have been ~s"
pass-name t (force answer))))))))
(define run-pass
(lambda (input-expr pass-name)
(when (memq pass-name (tracer)) (printf "~%~s:~%" pass-name))
(let ([pass (eval pass-name)])
(case pass-name
[(generate-x86-64)
(let ([output-string
(on-error
(begin
(if ordinal
(printf "~%Error occurred within pass ~s on test ~s" pass-name ordinal)
(printf "~%Error occurred within pass ~s" pass-name))
(when verbose?
(printf "~%~s input:~%" pass-name)
(pretty-print input-expr)))
(with-output-to-string
(lambda ()
(if (memq pass-name (timed-passes))
(begin
(printf "~s: " pass-name)
(flush-output-port)
(let-values ([(v t) (time-it (pass input-expr))])
(printf "~a\n" t)
v))
(pass input-expr)))))])
(when emit? (check-build-eval pass-name input-expr output-string))
(when (memq pass-name (tracer)) (display-string output-string))
input-expr)]
[else
(let ([output-expr
(on-error
(begin
(if ordinal
(printf "~%Error occurred within pass ~s on test ~s" pass-name ordinal)
(printf "~%Error occurred within pass ~s" pass-name))
(when verbose?
(printf "~%~s input:~%" pass-name)
(pretty-print input-expr)))
(if (memq pass-name (timed-passes))
(begin
(printf "~s: " pass-name)
(flush-output-port)
(let-values ([(v t) (time-it (pass input-expr))])
(printf "~a\n" t)
v))
(pass input-expr)))])
(when (memq pass-name (tracer))
(tracer-print output-expr))
(unless (or (check-final-output-only)
(memq pass-name (trusted-passes)))
(check-eval pass-name input-expr output-expr))
output-expr)]))))
(define run
(lambda (input-expr passes)
(define exit
(lambda (input-expr sp)
(if sp
(error 'driver "starting pass ~s not found" sp)
(when (check-final-output-only)
(check-eval 'final-output input-expr input-expr)))))
(let run ([input-expr input-expr]
[passes passes]
[sp (starting-pass)]
[continue exit]
[break exit])
(if (null? passes)
(continue input-expr sp)
(match (car passes)
[(break when ,pred)
(if (and (not sp) ((eval pred) input-expr))
(break input-expr sp)
(run input-expr (cdr passes) sp continue break))]
[(break unless ,pred)
(if (and (not sp) (not ((eval pred) input-expr)))
(break input-expr sp)
(run input-expr (cdr passes) sp continue break))]
[(iterate ,ipass* ...)
(let next-iter ([input-expr input-expr] [sp sp])
(run input-expr
ipass*
sp
(lambda (input-expr sp)
(if sp
(run input-expr (cdr passes) sp continue break)
(next-iter input-expr sp)))
(lambda (input-expr sp)
(run input-expr (cdr passes) sp continue break))))]
[,pass-name
(guard (symbol? pass-name))
(if (or (not sp) (eq? pass-name sp))
(run (run-pass input-expr pass-name) (cdr passes) #f continue break)
(begin
(when (eq? pass-name 'rename-var) (adjust-unc! input-expr))
(run input-expr (cdr passes) sp continue break)))])))))
(if (equal? (timed-passes) (all-pass-names))
(let-values ([(v t) (time-it (run original-input-expr (compiler-passes)))])
(printf "overall: ~a\n" t)
v)
(run original-input-expr (compiler-passes))))))
)
| true |
334a181850dd68a124082088bd8abefe79c526b8
|
ff11205b7e923cda050866a6411cdcbdeb8d631d
|
/imperative-command-line-a.scm
|
f1a99897c86429475b10f47b5a542e99aad46d4a
|
[
"BSD-3-Clause"
] |
permissive
|
retroj/imperative-command-line-a
|
ba16811a813ad6587af042ce908d3c24b3018305
|
2bc87757f9567f8f97d25827024ef209e59e474f
|
refs/heads/master
| 2021-01-19T02:17:19.580897 | 2016-06-17T01:01:13 | 2016-06-17T01:01:13 | 8,191,344 | 1 | 1 | null | 2015-06-19T16:46:07 | 2013-02-14T00:52:14 |
Scheme
|
UTF-8
|
Scheme
| false | false | 7,587 |
scm
|
imperative-command-line-a.scm
|
;; Copyright 2011-2013 John J Foerch. All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are
;; met:
;;
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; 2. Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in
;; the documentation and/or other materials provided with the
;; distribution.
;;
;; THIS SOFTWARE IS PROVIDED BY JOHN J FOERCH ''AS IS'' AND ANY EXPRESS OR
;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL JOHN J FOERCH OR CONTRIBUTORS BE LIABLE
;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
;; BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
;; OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
;; ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(module imperative-command-line-a
(make-command
command-name
command-args
command-doc
command-body
command-name-string
define-command-group
define-command-group*
make-command-group
abort-parse
parse
groups
make-title
help-heading
help-minimum-intercolumn-space
special-options)
(import chicken scheme)
(use srfi-1
srfi-13
data-structures
extras
(only miscmacros dotimes))
;;;
;;; Language
;;;
(define rest cdr)
(define (signal-parse-error msg . args)
(signal
(make-composite-condition
(make-property-condition 'exn
'location 'parse
'message msg
'arguments args)
(make-property-condition 'icla)
(make-property-condition 'parse))))
;;;
;;; Command
;;;
(define-record command
name args doc body)
(define (command-name-string command-def)
(symbol->string (command-name command-def)))
;;;
;;; Command Groups
;;;
(define groups (make-parameter '()))
(define-syntax %make-command
(syntax-rules (#:doc)
((%make-command (name . args) #:doc doc . body)
(make-command 'name 'args doc (lambda args . body)))
((%make-command (name . args) . body)
(%make-command (name . args) #:doc #f . body))))
(define make-title
(make-parameter
(lambda (sym)
(string-map!
(lambda (c) (if (char=? #\- c) #\space c))
(string-upcase! (symbol->string sym))))))
(define-record command-group
title commands)
(define-syntax define-command-group*
(syntax-rules (#:title)
((define-command-group* name #:title title command-def ...)
(define name (make-command-group
title
(list (%make-command . command-def)
...))))
((define-command-group* name . command-defs)
(define-command-group* name
#:title ((make-title) 'name)
. command-defs))))
(define-syntax define-command-group
(syntax-rules ()
((define-command-group name . args)
(begin
(define-command-group* name . args)
(groups (append! (groups) (list name)))))))
(define (find-command-def name command-group)
(find (lambda (x) (equal? name (command-name-string x)))
(command-group-commands command-group)))
;;;
;;; Call Info
;;;
(define-record callinfo
name args thunk)
(define %make-callinfo make-callinfo)
(define (make-callinfo def args)
(let ((name (command-name-string def))
(body (command-body def)))
(%make-callinfo name args
(lambda () (apply body args)))))
;;;
;;; Parser
;;;
(define (abort-parse)
(signal (make-property-condition 'abort-parse)))
(define (%parse input)
(let* ((callinfos (map (lambda (x) (list)) (groups))))
(let loop ((input input)
(count (length input)))
(cond
((null? input) callinfos)
(else
(let* ((opsym (first input))
(input (rest input))
(count (- count 1))
(op (string-trim opsym #\-))
(def #f)
(group-index (list-index
(lambda (group)
(set! def (find-command-def op group))
def)
(groups))))
(unless def
(signal-parse-error "unexpected symbol" opsym))
(let ((narg (length (command-args def))))
(when (< count narg)
(signal-parse-error
(sprintf "~A requires ~A arguments, but only ~A were given"
op narg count)))
(let ((d (list-tail callinfos group-index)))
(set-car! d (append! (car d) (list (make-callinfo def (take input narg))))))
(loop (list-tail input narg) (- count narg)))))))))
(define (parse input)
(let ((callinfos (apply append! (%parse input)))
(called 0))
(condition-case
(begin
(for-each
(lambda (cmd)
(set! called (+ 1 called))
((callinfo-thunk cmd)))
callinfos)
#t)
((abort-parse)
(let ((uncalled (drop callinfos called)))
(unless (null? uncalled)
(printf "~%Warning: the following commands were ignored:~%")
(for-each
(lambda (x) (printf " ~S~%" (cons (callinfo-name x) (callinfo-args x))))
uncalled))
#f)))))
;;;
;;; Default Command Group(s)
;;;
(define help-heading (make-parameter #f))
(define help-minimum-intercolumn-space (make-parameter 3))
(define-command-group special-options
#:title "SPECIAL OPTIONS (evaluate first one and exit)"
((help)
#:doc "displays this help"
(let ((longest
(fold max 0
(map
(lambda (def)
(apply + 2 (string-length (command-name-string def))
(* 3 (length (command-args def)))
(map (compose string-length symbol->string)
(command-args def))))
(append-map command-group-commands (groups))))))
(define (help-section option-group)
(for-each
(lambda (def)
(let ((col1 (apply string-append " -" (command-name-string def)
(map (lambda (a)
(string-append " <" (symbol->string a) ">"))
(command-args def)))))
(display col1)
(when (command-doc def)
(dotimes (_ (+ (help-minimum-intercolumn-space)
(- longest (string-length col1))))
(display " "))
(display (command-doc def)))
(newline)))
option-group))
(print (help-heading))
(for-each
(lambda (group)
(let ((title (command-group-title group))
(commands (command-group-commands group)))
(printf "~%~A~%~%" title)
(help-section commands)))
(groups))
(newline)
(abort-parse)))
((version)
#:doc "prints the version"
(print (help-heading))
(abort-parse)))
)
| true |
57b5971477b12191582363b8d0f920500be395d3
|
abc7bd420c9cc4dba4512b382baad54ba4d07aa8
|
/src/old/chez/basic_graphics.ss
|
2977965f3b4b145a9465debd21b79f165ed4031a
|
[
"BSD-3-Clause"
] |
permissive
|
rrnewton/WaveScript
|
2f008f76bf63707761b9f7c95a68bd3e6b9c32ca
|
1c9eff60970aefd2177d53723383b533ce370a6e
|
refs/heads/master
| 2021-01-19T05:53:23.252626 | 2014-10-08T15:00:41 | 2014-10-08T15:00:41 | 1,297,872 | 10 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 24,763 |
ss
|
basic_graphics.ss
|
;; [2007.09.06]
;; This code is long dead. I don't use the token machine backend at
;; all, much less the network simulator and GUI.
;; [2004.05.24]
;; This implements my simple "basic graphics" interface, which I will
;; document somewhere as soon as it's done. Erg, you'd think this
;; would be part of slib?
;; THERE IS NO ABSTRACTION BOUNDARY BETWEEN THIS AND GRAHPICS_STUB.SS
;; TODO FIXME: REMOVE eval's FROM THIS AND GRAPHICS_STUB.ss
;; (HAVING PROBLEMS WITH RECORD-TYPES CURRENTLY. evals ARE A HACK)
;;;; TODO: Refactor this into a separate file for the GUI as opposed to the graphics ops.
; ======================================================================
;; [2004.06.21] Adding "draw-mark" to the interface, I use this for
;; drawing 'X' marks for additional debugging info.
(chez:module basic_graphics (
init-graphics close-graphics
rec->rgb ;; This converts rgb records into system specific (SWL) rgb values.
make-rgb rgb? rgb-red rgb-green rgb-blue
the-win
;; current-drawing-color
;; current-filling-color
;; current-background-color
;;;;; draw-ellipse
flash-text ;thread-eval
)
(import constants)
;; Only for swl1.0+ Gives us define-class, etc.
(import swl:oop)
(import (except swl:generics rgb-red rgb-green rgb-blue))
(import (except swl:macros mvlet))
(import swl:option)
(import swl:threads)
;; This global variable points to the drawing surface itself.
(define the-win #f)
(define the-winframe #f)
;; [2005.11.25] The button panel:
(define the-panel #f)
(define the-panel2 #f)
(define the-viewer-thread #f)
;; [private] A single line of text used for messages to the user.
(define the-text-readout #f)
;; [Chez] This simply makes a SWL rgb value out of our standard record representation.
(define (rec->rgb rec)
(make <rgb> (rgb-red rec) (rgb-green rec) (rgb-blue rec)))
; Module local bindings:
(define current-drawing-color (rec->rgb Default-Drawing-Color))
(define current-filling-color #f)
(define current-background-color (rec->rgb Default-Background-Color))
;; Here's where we keep objects that are to be drawn:
(define object-buffer '())
;; And here's where we keep the objects that are on the screen:
(define screen-buffer '())
; ======================================================================
#;
(define (flash ob ms)
(thread-fork
(lambda ()
(show ob)
(thread-sleep ms)
(destroy ob))))
;(define (new-timer t th) (thread-fork (lambda () (thread-sleep ms) (th))))
;; Flashes a bit of text at the bottom of the GUI window for a given period of time.
(define flash-text
; Currently this list should only contain one flash:
(let ((current-flashes '()))
(lambda (txt ms)
(if (not the-text-readout)
(error 'flash-text "the-text-readout is null, graphics must not be initialized."))
(critical-section
(for-each thread-kill current-flashes)
(set-title! the-text-readout "")
(let ((newthread (thread-fork
(lambda ()
(let ((snapshot (get-title the-text-readout)))
(set-title! the-text-readout txt)
(thread-sleep ms)
;; If we haven't been displaced, reset text:
;(if (equal? txt (get-title the-text-readout)) (set-title! the-text-readout snapshot))
(set-title! the-text-readout "")
(critical-section
(set! current-flashes (remq (thread-self) current-flashes)))
(thread-kill)
)))))
(set! current-flashes (cons newthread current-flashes)))))))
;; Init the graphics system, bring up a window.<br>
;; [2005.11.25] Man I'm having some serious annoyance figuring out how to do proper layout with SWL.
;; <br>
;; <br> [2005.11.26] NOTE: Having problems with modules/imports/records here. Using 'eval' as a hack: (FIXME)
(define (init-graphics)
;; [internal] A list of thunks to call when the view is being updated.
(define view-update-hooks '())
;; [internal] This entry calls its action every time a key is typed:
(define-class (<better-entry> parent) (<entry> parent)
(ivars (parent parent))
(inherited) (inheritable)
(private) (protected)
(public
;[mouse-leave (x y mods) ((get-action self) self)]
[key-release (k mods) ((get-action self) self)]
[key-press (c mods)
(send-base self key-press c mods)
(send parent key-press c mods)
]
))
;; [internal] This class displays a label next to the entry, and
;; monitors the associated numeric parameter for changes, updating
;; the view accordingly.
(define-class (<numeric-param-entry> name label param parent) (<frame> parent)
(ivars (label-obj #f) (entry-obj #f) (counter 0))
(inherited) (inheritable) (private) (protected)
(public
;[mouse-leave (x y mods) ((get-action self) self)]
[key-press (c mods)
(set! counter 8)]
[init (nm lab prm prnt)
(send-base self init prnt)
(set! entry-obj
(create <better-entry> self with (width/char: 4)
(action: (lambda (self)
(let ((num (string->number (get-string self))))
(when num
(flash-text (format "Setting ~a: ~s\n" nm (get-string self)) 1000)
(prm num)))))
;(fill-color: Default-Window-Text-Color)
))
(insert entry-obj (number->string (prm)))
(set! label-obj (create <label> self with (title: lab)))
(pack entry-obj (side: 'left))
(pack label-obj (side: 'right))
(set-background-color! self (rec->rgb Default-Window-Color))
(set-background-color! entry-obj (rec->rgb Default-Window-Color))
(set-background-color! label-obj (rec->rgb Default-Window-Color))
;; Add an update hook for this:
(set! view-update-hooks
;; I don't have a good way to tell when the user is editing this entry.
;; (It's very annoying when we reset over what they're trying to type.)
;; So what I do is I set the counter above when a key
;; is pressed, and it must count down to zero before we'll touch the contents.
(cons (lambda ()
(if (zero? counter)
(let ((curval (string->number (get-string entry-obj))))
(unless (equal? (prm) curval)
(delete-all entry-obj)
(insert entry-obj (number->string (prm)))))
(set! counter (sub1 counter))))
view-update-hooks))
]
[set-width/char! (n) (set-width/char! entry-obj n)]
))
;; [internal] This class is a check-button that also manages the book-keeping.
(define-class (<bool-param-button> name label param parent) (<checkbutton> parent)
(ivars)
(inherited) (inheritable) (private) (protected)
(public
;[mouse-leave (x y mods) ((get-action self) self)]
[init (nm lab prm prnt)
(send-base self init prnt)
(set-title! self lab)
(if (prm) (send self select) (send self deselect))
(set-action! self
(lambda (self)
;(set! realtime-state (not realtime-state))
(prm (not (prm)))
(flash-text (format "Setting ~a: ~a\n" nm (prm)) 1000)
(if (prm) (send self select) (send self deselect))))
(set-background-color! self (rec->rgb Default-Window-Color))
(set! view-update-hooks
(cons (lambda ()
(if (prm) (send self select) (send self deselect)))
view-update-hooks))]
))
;; [internal] This class provides a set of radio buttons for a Regiment parameter. <br>
;;
;; .param name - The symbolic name of the parameter
;; .param label - The user-visible label for the widget.
;; .param param - The parameter closure itself
;; .param options - An association list binding option title
;; (string) to a thunk for creating a new object to bind to the
;; parameter when the corresponding button is pressed.
;; .param parent - As usual with SWL, the parent widget.
(define-class (<radio-param-selector> name label param options parent) (<frame> parent)
(ivars)
(inherited) (inheritable) (private) (protected)
(public
[init (name label param options parent)
(send-base self init parent)
(set-background-color! self (rec->rgb Default-Window-Color))
(let ((buttons
(map (lambda (option)
(list (cadr option)
(create <radiobutton> self with (title: (format "~a" (car option)))
(action: (lambda _ (param ((cadr option)))))
(background-color: (rec->rgb Default-Window-Color)))))
options)))
(pack (create <label> self with (title: label)
(background-color: (rec->rgb Default-Window-Color))) (anchor: 'w))
(for-each (lambda (b) (pack (cadr b) (anchor: 'w))) buttons)
;; Look up the current value of the parameter in the list we just created.
(let ((entry (assq (param) buttons)))
(if (not entry)
(IFDEBUG
(warning '<radio-param-selector>
"Parameter ~a has unknown current value: ~a" name (param))
(void))
;; Otherwise select the correct button:
(send (cadr entry) select))))
]))
;; [internal] This is the regiment drawing surface.
(define-class (<regiment-canvas> parent) (<canvas> parent)
(ivars)
(inherited) (inheritable) (private) (protected)
(public
[key-press (c mods)
(send-base self key-press c mods)
(flash-text (format "Key pressed: ~s" c) 1000)]
))
;; We set up a single additional thread for evaluation. It receives
;; expressions via this queue.
; (define eval-queue (thread-make-msg-queue 'graphics-eval-queue))
; (define (thread-eval exp) (thread-send-msg eval-queue exp))
(define sim-busy #f)
(define (thread-eval exp)
(thread-fork (lambda () (let ((snap sim-busy))
(set! sim-busy #t)
(eval exp)
(set! sim-busy snap)
(printf "Simulation Finished.\n")
(flash-text "Simulation Finished." 900)
(thread-kill)))))
;; (printf "Running graphical interface to simple simulator.~n")
(if the-win
(printf "Graphics already open!!~n")
(let ([pause-queue (thread-make-msg-queue 'pause-queue)]
[group #f])
(set! the-winframe (create <toplevel> with
(title: "Region Streams Demo")
(background-color: (rec->rgb Default-Window-Color))
))
(set! group (create <frame> the-winframe with
(background-color: (rec->rgb Default-Window-Color))))
(set! the-panel (create <frame> group ;the-winframe
with
;(width: (in->pixels 1)) ;(+ window-width 200))
;(height: window-height)
;(background-color: (make <rgb> 100 50 50))
(background-color: (rec->rgb Default-Window-Color))
))
(set! the-panel2 (create <frame> the-winframe
with
;(width: (in->pixels 1)) ;(+ window-width 200))
;(height: window-height)
;(background-color: (make <rgb> 100 50 50))*
(background-color: (rec->rgb Default-Window-Color))
))
(set! the-win (create <regiment-canvas> group ;the-winframe
with
(width: window-width) ;(in->pixels 5))
(height: (+ window-height 25)) ;(in->pixels 5))
(background-color: (rec->rgb Default-Background-Color))
))
(set! the-text-readout (create <canvas-text> the-win (- (/ window-width 2) 10) (- window-height -15);13)
with (title: "")
(fill-color: (rec->rgb Default-Canvas-Text-Color))
))
;; We start up a single additional thread for evaluation:
#;
(thread-fork (lambda ()
(let ((winsnap the-win))
(let graphics-eval-loop ()
;; Run until the-win changes.
(when (eq? winsnap the-win)
(let ((exp (thread-receive-msg eval-queue)))
(unless (eq? exp 'kill)
(eval exp)
(graphics-eval-loop))))))))
(let* (
[pause-button (create <button> the-panel with (title: "Pause")
(action:
(lambda (self)
(if (simalpha-pause-hook)
(begin (set-title! self "Pause")
(printf "Simulation Unpaused.\n")
(flash-text "Simulation Unpaused." 600)
(set! sim-busy #t)
(simalpha-pause-hook #f)
(thread-send-msg pause-queue 'continue)
)
(begin (set-title! self "Play")
(flash-text "Simulation Paused." 600)
(set! sim-busy #f)
;; This tells the simulator thread to pause and wait for a msg:
(simalpha-pause-hook (lambda ()
(if (eq? 'kill (thread-receive-msg pause-queue))
(thread-kill))
))
))
)))]
[realtime-button (create <bool-param-button> 'simalpha-realtime-mode
"Realtime" simalpha-realtime-mode the-panel2)]
[msgcounts-button (create <bool-param-button> 'simalpha-label-msgcounts
"Show MsgCounts" simalpha-label-msgcounts the-panel2)]
[sensorshow-button (create <bool-param-button> 'simalpha-label-sensorvals
"Show SensorVals" simalpha-label-sensorvals the-panel2)]
;; UNFINISHED:
[showedges-state #t]
[showedges-button (create <button> the-panel2 with (title: "Hide Edges")
(action: (lambda (self)
(set! showedges-state (not showedges-state))
(let ((edges
(list-rem-dups
(apply append
(map (lambda (x)
(map cadr (gobject-edgelist (simobject-gobj x))))
(simworld-all-objs (simalpha-current-simworld)))))))
(if showedges-state
(for-each show edges)
(for-each hide edges))))))]
[num-nodes-widget
(create <numeric-param-entry> 'sim-num-nodes "NumNodes" sim-num-nodes the-panel2
with (width/char: 4))]
[timeout-widget
(create <numeric-param-entry> 'sim-timeout "Timeout" sim-timeout the-panel2
with (width/char: 6))]
;; TODO: Abstract to use the generic <radio-param-selector> class for this:
[placement-widget
(let* ((f (create <frame> the-panel2 with
(background-color: (rec->rgb Default-Window-Color))))
(b1 (create <radiobutton> f with (title: "Connected")
(action: (lambda _ (simalpha-placement-type 'connected)))
(background-color: (rec->rgb Default-Window-Color))))
(b2 (create <radiobutton> f with (title: "Gridlike")
(action: (lambda _ (simalpha-placement-type 'gridlike)))
(background-color: (rec->rgb Default-Window-Color))))
(b3 (create <radiobutton> f with (title: "Random")
(action: (lambda _ (simalpha-placement-type 'random)))
(background-color: (rec->rgb Default-Window-Color)))))
(pack b1 (anchor: 'w))
(pack b3 (anchor: 'w))
(pack b2 (anchor: 'w))
(pack (create <numeric-param-entry> 'simalpha-max-gridlike-perturbation
"GridPerturb" simalpha-max-gridlike-perturbation the-panel2
with (width/char: 4))) ;(anchor: 'w))
(case (simalpha-placement-type)
[(connected) (send b1 select)]
[(gridlike) (send b2 select)]
[(random) (send b3 select)])
;(let ((f2 (create <frame> f)))
; (let ((e (create <better-entry> f with (width/char: 4)
; (action: (lambda (self)
; (flash-text (format "Setting simalpha-max-gridlike-perturbation: ~s\n" (get-string self)) 1000)
; (let ((num (string->number (get-string self))))
; (if num (simalpha-max-gridlike-perturbation num))))))))
; (insert e (number->string (simalpha-max-gridlike-perturbation)))
; (pack e (side: 'left))
; (pack (create <label> f with (title: "GridPerturbation")) (side: 'right)))
f)]
; Haha radio button for the radio widget...
[radio-widget
(let* ((f (create <frame> the-panel2 with
(background-color: (rec->rgb Default-Window-Color))))
(b1 (create <radiobutton> f with (title: "Lossless")
(action: (lambda _ (simalpha-channel-model 'lossless)))
(background-color: (rec->rgb Default-Window-Color))))
(b2 (create <radiobutton> f with (title: "LinearDisc")
(action: (lambda _ (simalpha-channel-model 'linear-disc)))
(background-color: (rec->rgb Default-Window-Color)))))
(pack b1 (anchor: 'w))
(pack b2 (anchor: 'w))
(case (simalpha-channel-model)
[(lossless) (send b1 select)]
[(linear-disc) (send b2 select)])
(pack (create <numeric-param-entry> 'simalpha-inner-radius "Inner radius" simalpha-inner-radius f
with (width/char: 3)) (anchor: 'w))
(pack (create <numeric-param-entry> 'simalpha-outer-radius "Outer radius" simalpha-outer-radius f
with (width/char: 3)) (anchor: 'w))
f)]
[sensor-widget
(create <radio-param-selector> 'simalpha-sense-function-constructor "Sensor Readings"
simalpha-sense-function
`(["Sine Wave" ,sense-sine-wave]
["Noise-Rising" ,sense-noisy-rising]
["Random 1-100" ,sense-random-1to100]
["Dist to Origin" ,sense-dist-from-origin]
["Spatial Sine Wave" ,sense-spatial-sine-wave])
the-panel2)]
[clock-readout (create <canvas-text> the-win
60 ;(- (/ window-width 2) 10)
(- window-height -10) ;13)
with (title: "t = ")
(fill-color: (rec->rgb Default-Canvas-Text-Color))
(font: (create <font> 'times 16 '(bold))))]
[rerun-button (create <button> the-panel with (title: "Rerun Sim")
(action: (lambda (self)
(unless sim-busy
(set-title! the-text-readout "")
; Kill existing evaluations if they exist:
(when (simalpha-pause-hook) (simalpha-pause-hook #f)
(thread-send-msg pause-queue 'kill) (set! sim-busy #f))
(set-title! pause-button "Pause")
(printf "\nRerunning Simulator!\n")
(thread-eval '(rerun-simulator-alpha 'use-stale-world)))
)))]
[restart-button (create <button> the-panel with (title: "Reroll network")
(action: (lambda (self)
(unless sim-busy
(set-title! the-text-readout "")
(when (simalpha-pause-hook) (simalpha-pause-hook #f)
(thread-send-msg pause-queue 'kill) (set! sim-busy #f))
(set-title! pause-button "Pause")
(printf "\nRerunning Simulator!\n")
(thread-eval '(rerun-simulator-alpha))
(thread-fork
(lambda () ((get-action pause-button) pause-button)))
))))]
[printstats-button (create <button> the-panel with (title: "Print Stats")
(action: (lambda (_)
;; This runs asynchronously:
(eval '(print-stats)))))]
[printconn-button (create <button> the-panel with (title: "Print Connectivity")
(action: (lambda (_)
;; This runs asynchronously:
(eval '(print-connectivity (simalpha-current-simworld))))))]
[savetopo-button (create <button> the-panel with (title: "Save Topology")
(action: (lambda (_)
;; This runs asynchronously:
;; Could have problems with concurrent modification of simalpha-current-simworld.
(eval
'(with-output-to-file (swl:file-dialog "Save Topology" 'save)
(lambda ()
(parameterize ([print-level #f]
[print-length #f]
[print-graph #t])
(write (freeze-world (simalpha-current-simworld)))
))
'replace)))))]
)
;; This is the thread that periodically updates the view by polling various state.
(set! the-viewer-thread
(thread-fork (let ([win the-win]
;[sim (simalpha-current-simworld)]
)
;(inspect (list (simworld? sim) ((top-level-value 'simworld?) sim) sim))
;(DEBUGASSERT (simworld? sim))
(lambda ()
(let viewer-update-loop ()
;; If the window has changed or been destroyed, we kill this thread.
(if (not (eq? win the-win)) (thread-kill))
(DEBUGASSERT (simworld? (simalpha-current-simworld)))
; Draw the clock in the corner of the screen.
(set-title! clock-readout
(format "t = ~s"
(if (simalpha-current-simworld)
(simworld-vtime (simalpha-current-simworld))
'??)))
(show clock-readout)
; This updates all the message labels.
(if (simalpha-label-msgcounts)
(eval ; Was using thread-eval for this. How long should it take?
'(for-each (lambda (ob)
(sim-setlabel (format "~a->~a"
(simobject-local-recv-messages ob)
(simobject-local-sent-messages ob)) ob))
(simworld-all-objs (simalpha-current-simworld)))))
;; And this updates the labels to reflect sensor values.
(if (simalpha-label-sensorvals)
(eval
'(let ((vtime (simworld-vtime (simalpha-current-simworld))))
(for-each
(lambda (ob)
(let ((reading (((simalpha-sense-function) vtime)
'default
(node-id (simobject-node ob))
(car (node-pos (simobject-node ob)))
(cadr (node-pos (simobject-node ob)))
)))
(sim-setlabel
(if (number? reading)
(number->string (round-to 2 reading))
(format "~a" reading))
ob)))
(simworld-all-objs (simalpha-current-simworld))))))
;; Now call any other update hooks:
;; (Right now [2005.11.27] this is used for the text entry fields.)
(for-each (lambda (th) (th)) view-update-hooks)
(thread-sleep 250)
(viewer-update-loop))))))
;; Let's add a bit more to wipe those msg count readouts when we turn the param off:
(let ((oldac (get-action msgcounts-button)))
(set-action! msgcounts-button
(lambda (self)
(oldac self)
(if (not (simalpha-label-msgcounts))
(eval '(for-each (lambda (x) (sim-setlabel "" x))
(simworld-all-objs (simalpha-current-simworld))))))))
;; Same for showing the sensor vals:
(let ((oldac (get-action sensorshow-button)))
(set-action! sensorshow-button
(lambda (self)
(oldac self)
(if (not (simalpha-label-sensorvals))
(eval '(for-each (lambda (x) (sim-setlabel "" x))
(simworld-all-objs (simalpha-current-simworld))))))))
; (send showedges-button toggle)
(show the-winframe)
(pack pause-button (side: 'left))
(pack restart-button (side: 'left))
(pack rerun-button (side: 'left))
(pack printstats-button (side: 'left))
(pack printconn-button (side: 'left))
(pack savetopo-button (side: 'left))
(pack sensor-widget)
(pack (create <label> the-panel2 with (title: "Topology")
(background-color: (rec->rgb Default-Window-Color))) (anchor: 'w))
(pack placement-widget );(anchor: 'w)) ;(side: 'left))
(pack (create <label> the-panel2 with (title: "\nRadio")
(background-color: (rec->rgb Default-Window-Color))) (anchor: 'w))
(pack radio-widget )
(pack realtime-button (anchor: 'w)) ;(side: 'left) (anchor: 'se))
(pack msgcounts-button (anchor: 'w)) ;(side: 'left) (anchor: 'se))
(pack sensorshow-button (anchor: 'w)) ;(side: 'left) (anchor: 'se))
(pack num-nodes-widget (anchor: 'w)) ;(side: 'left))
(pack timeout-widget (anchor: 'w)) ;(side: 'left))
(pack showedges-button );(anchor: 'w)) ;(side: 'left)
(pack the-win (side: 'top))
(pack the-panel (side: 'bottom))
(pack group (side: 'left))
(pack the-panel2 (side: 'right))
;; By convention, returns a thunk that will pause/unpause.
;(get-action pause-button)
;pause-button
))))
(define (close-graphics)
(if the-win
(begin
(destroy the-win)
(destroy the-winframe)
(set! the-win #f)
(set! the-winframe #f))
(printf "Graphics already closed!~n")))
#;
(define (clear-buffer)
(for-each destroy object-buffer)
(set! object-buffer '())
)
;; [2005.11.25] Not used right now:
#;
;; This may optionally destroy the object buffer as well:
(define (paint-buffer)
;; This requires them be seperate in memory:
(for-each destroy screen-buffer)
(for-each show object-buffer)
(set! screen-buffer object-buffer)
(set! object-buffer '())
)
#;(define draw-ellipse
(let ((drawit (lambda (x1 y1 x2 y2 draw fill)
(let ((circ (create <oval> the-win x1 y1 x2 y2)))
(set-outline-color! circ
(make <rgb>
(rgb-red draw) (rgb-green draw) (rgb-blue draw)))
(if fill (set-fill-color!
circ
(make <rgb> (rgb-red fill) (rgb-green fill) (rgb-blue fill))))
;(show circ)
(hide circ)
(set! object-buffer (cons circ object-buffer))
))))
(case-lambda
[(x1 y1 x2 y2) (drawit x1 y1 x2 y2 current-drawing-color current-filling-color)]
[(x1 y1 x2 y2 c1) (drawit x1 y1 x2 y2 c1 current-filling-color)]
[(x1 y1 x2 y2 c1 c2) (drawit x1 y1 x2 y2 c1 c2)])))
;======================================================================
;;; HOOKS
;; This changes the screen radius
(add-parameter-hook 'sim-num-nodes
(lambda (_) (set-procesor-screen-radius!)))
);; End module
| false |
b3519737eb102c854d7ca6aa84f0bf24a42fedb4
|
2bcf33718a53f5a938fd82bd0d484a423ff308d3
|
/programming/sicp/ch3/ex-3.74.scm
|
f5277581f987533945e19793e005c24cad83576e
|
[] |
no_license
|
prurph/teach-yourself-cs
|
50e598a0c781d79ff294434db0430f7f2c12ff53
|
4ce98ebab5a905ea1808b8785949ecb52eee0736
|
refs/heads/main
| 2023-08-30T06:28:22.247659 | 2021-10-17T18:27:26 | 2021-10-17T18:27:26 | 345,412,092 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 661 |
scm
|
ex-3.74.scm
|
#lang sicp
(#%require "stream.scm")
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-24.html#%_thm_3.74
(define (sign-change-detector v1 v2)
(cond ((and (> v1 0) (< v2 0)) -1)
((and (< v1 0) (> v2 0)) 1)
(else 0)))
(define sense-data (list->stream (list 1 2 1.5 1 0.5 -0.1 -2 -3 -2 -0.5 0.2 3 4)))
;; Need to use (cons-stream 0 sense-data) not (stream-cdr sense-data) so that
;; we emit something at the first element of the input stream (always 0).
(define zero-crossings
(stream-map sign-change-detector
sense-data
(cons-stream 0 sense-data)))
(display-stream zero-crossings)
| false |
b24789d244cb6bdfdcd75b312a3de1956e92c5bb
|
98fd12cbf428dda4c673987ff64ace5e558874c4
|
/sicp/v1/chapter-3.3/scott.scm
|
e9fa1801fccc8c5d0b0ef9d71530667b5a02f357
|
[
"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
|
Scheme
| false | false | 15,639 |
scm
|
scott.scm
|
;;;SECTION 3.3.2
(define (front-ptr queue)
(car queue))
(define (rear-ptr queue)
(cdr queue))
(define (set-front-ptr! queue item)
(set-car! queue item))
(define (set-rear-ptr! queue item)
(set-cdr! queue item))
(define (empty-queue? queue)
(null? (front-ptr queue)))
(define (make-queue)
(cons '() '()))
(define (front-queue queue)
(if (empty-queue? queue)
(error "FRONT called with an empty queue" queue)
(car (front-ptr queue))))
(define (insert-queue! queue item)
(let ((new-pair (cons item '())))
(cond
((empty-queue? queue)
(set-front-ptr! queue new-pair)
(set-rear-ptr! queue new-pair)
queue)
(else
(set-cdr! (rear-ptr queue) new-pair)
(set-rear-ptr! queue new-pair)
queue))))
(define (delete-queue! queue)
(cond
((empty-queue? queue) (error "DELETE! called with an empty queue" queue))
(else
(set-front-ptr! queue (cdr (front-ptr queue)))
queue)))
;; section 3.3.4
; (define a (make-wire))
;: (define b (make-wire))
;: (define c (make-wire))
;: (define d (make-wire))
;: (define e (make-wire))
;: (define s (make-wire))
;:
;: (or-gate a b d)
;: (and-gate a b c)
;: (inverter c e)
;: (and-gate d e s)
;; exercise 3.28 or-gate
(define (logical-or x y)
(if (or (= x 1) (= y 1))
1
0))
(define (or-gate a1 a2 output)
(define (or-action-procedure)
(let ((new-value (logical-or (get-signal a1) (get-signal a2))))
(after-delay or-gate-delay (lambda ()
(set-signal! output new-value)))))
(add-action! a1 or-action-procedure)
(add-action! a2 or-action-procedure)
'ok)
;;; exercise 3.29 composite or gate
(define (or-gate-2 a b output)
(let ((c (make-wire))
(d (make-wire))
(e (make-wire)))
(inverter a c)
(inverter b d)
(and-gate c d e)
(inverter e output)
'ok))
;;NB. To use half-adder, need or-gate from exercise 3.28
(define (half-adder a b s c)
(let ((d (make-wire))
(e (make-wire)))
(or-gate a b d)
(and-gate a b c)
(inverter c e)
(and-gate d e s)
'ok))
(define (full-adder a b c-in sum c-out)
(let ((s (make-wire))
(c1 (make-wire))
(c2 (make-wire)))
(half-adder b c-in s c1)
(half-adder a s sum c2)
(or-gate c1 c2 c-out)
'ok))
(define (inverter input output)
(define (invert-input)
(let ((new-value (logical-not (get-signal input))))
(after-delay inverter-delay (lambda ()
(set-signal! output new-value)))))
(add-action! input invert-input)
'ok)
(define (logical-not s)
(cond
((= s 0) 1)
((= s 1) 0)
(else (error "Invalid signal" s))))
;;; from ch3support.scm
(define (logical-and x y)
(if (and (= x 1) (= y 1))
1
0))
;; *following uses logical-and -- see ch3support.scm
(define (and-gate a1 a2 output)
(define (and-action-procedure)
(let ((new-value (logical-and (get-signal a1) (get-signal a2))))
(after-delay and-gate-delay (lambda ()
(set-signal! output new-value)))))
(add-action! a1 and-action-procedure)
(add-action! a2 and-action-procedure)
'ok)
(define (make-wire)
(let ((signal-value 0)
(action-procedures '()))
(define (set-my-signal! new-value)
(if (not (= signal-value new-value))
(begin
(set! signal-value new-value)
(call-each action-procedures))
'done))
(define (accept-action-procedure! proc)
(set! action-procedures (cons proc action-procedures))
(proc))
(define (dispatch m)
(cond
((eq? m 'get-signal) signal-value)
((eq? m 'set-signal!) set-my-signal!)
((eq? m 'add-action!) accept-action-procedure!)
(else (error "Unknown operation -- WIRE" m))))
dispatch))
(define (call-each procedures)
(if (null? procedures)
'done
(begin ((car procedures)) (call-each (cdr procedures)))))
(define (get-signal wire)
(wire 'get-signal))
(define (set-signal! wire new-value)
((wire 'set-signal!) new-value))
(define (add-action! wire action-procedure)
((wire 'add-action!) action-procedure))
(define (after-delay delay action)
(add-to-agenda!
(+ delay (current-time the-agenda))
action
the-agenda))
(define (propagate)
(if (empty-agenda? the-agenda)
'done
(let ((first-item (first-agenda-item the-agenda)))
(first-item)
(remove-first-agenda-item! the-agenda)
(propagate))))
(define (probe name wire)
(add-action! wire (lambda ()
(newline)
(display name)
(display " ")
(display (current-time the-agenda))
(display " New-value = ")
(display (get-signal wire)))))
;;;Implementing agenda
(define (make-time-segment time queue)
(cons time queue))
(define (segment-time s)
(car s))
(define (segment-queue s)
(cdr s))
(define (make-agenda)
(list 0))
(define (current-time agenda)
(car agenda))
(define (set-current-time! agenda time)
(set-car! agenda time))
(define (segments agenda)
(cdr agenda))
(define (set-segments! agenda segments)
(set-cdr! agenda segments))
(define (first-segment agenda)
(car (segments agenda)))
(define (rest-segments agenda)
(cdr (segments agenda)))
(define (empty-agenda? agenda)
(null? (segments agenda)))
(define (add-to-agenda! time action agenda)
(define (belongs-before? segments)
(or
(null? segments)
(< time (segment-time (car segments)))))
(define (make-new-time-segment time action)
(let ((q (make-queue)))
(insert-queue! q action)
(make-time-segment time q)))
(define (add-to-segments! segments)
(if (= (segment-time (car segments)) time)
(insert-queue! (segment-queue (car segments)) action)
(let ((rest (cdr segments)))
(if (belongs-before? rest)
(set-cdr!
segments
(cons (make-new-time-segment time action) (cdr segments)))
(add-to-segments! rest)))))
(let ((segments (segments agenda)))
(if (belongs-before? segments)
(set-segments!
agenda
(cons (make-new-time-segment time action) segments))
(add-to-segments! segments))))
(define (remove-first-agenda-item! agenda)
(let ((q (segment-queue (first-segment agenda))))
(delete-queue! q)
(if (empty-queue? q)
(set-segments! agenda (rest-segments agenda)))))
(define (first-agenda-item agenda)
(if (empty-agenda? agenda)
(error "Agenda is empty -- FIRST-AGENDA-ITEM")
(let ((first-seg (first-segment agenda)))
(set-current-time! agenda (segment-time first-seg))
(front-queue (segment-queue first-seg)))))
;;; sample simulation
(define the-agenda (make-agenda))
(define inverter-delay 2)
(define and-gate-delay 3)
(define or-gate-delay 5)
;:
(define input-1 (make-wire))
(define input-2 (make-wire))
(define sum (make-wire))
(define carry (make-wire))
;:
(probe 'sum sum)
(probe 'carry carry)
;:
(half-adder input-1 input-2 sum carry)
(set-signal! input-1 1)
(propagate)
;:
(set-signal! input-2 1)
(propagate)
;;; Playing with the or gates
(define a (make-wire))
(define b (make-wire))
(define c (make-wire))
(probe 'a a)
(probe 'b b)
(probe 'c c)
(or-gate a b c)
(set-signal! a 0)
(set-signal! b 1)
(propagate)
(define d (make-wire))
(define e (make-wire))
(define f (make-wire))
(probe 'd d)
(probe 'e e)
(probe 'f f)
(or-gate-2 d e f)
(set-signal! d 0)
(set-signal! e 0)
(propagate)
;;;
;;;
;;;
;;;
;;;
;;; Section 3.3.5 Constraint Propagation
;;;
(define true #t)
(define false #f)
(define (inform-about-value constraint)
(constraint 'I-have-a-value))
(define (inform-about-no-value constraint)
(constraint 'I-lost-my-value))
(define (multiplier m1 m2 product)
(define (process-new-value)
(cond
((or
(and (has-value? m1) (= (get-value m1) 0))
(and (has-value? m2) (= (get-value m2) 0)))
(set-value! product 0 me))
((and (has-value? m1) (has-value? m2)) (set-value!
product
(* (get-value m1) (get-value m2))
me))
((and (has-value? product) (has-value? m1)) (set-value!
m2
(/ (get-value product) (get-value m1))
me))
((and (has-value? product) (has-value? m2)) (set-value!
m1
(/ (get-value product) (get-value m2))
me))))
(define (process-forget-value)
(forget-value! product me)
(forget-value! m1 me)
(forget-value! m2 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 -- MULTIPLIER" request))))
(connect m1 me)
(connect m2 me)
(connect product me)
me)
(define (constant value connector)
(define (me request)
(error "Unknown request -- CONSTANT" request))
(connect connector me)
(set-value! connector value me)
me)
(define (probe name connector)
(define (print-probe value)
(newline)
(display "Probe: ")
(display name)
(display " = ")
(display value))
(define (process-new-value)
(print-probe (get-value connector)))
(define (process-forget-value)
(print-probe "?"))
(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 -- PROBE" request))))
(connect connector me)
me)
(define (make-connector)
(let ((value false)
(informant false)
(constraints '()))
(define (set-my-value newval setter)
(cond
((not (has-value? me))
(set! value newval)
(set! informant setter)
(for-each-except setter inform-about-value constraints))
((not (= value newval)) (error "Contradiction" (list value newval)))
(else 'ignored)))
(define (forget-my-value retractor)
(if (eq? retractor informant)
(begin
(set! informant false)
(for-each-except retractor inform-about-no-value constraints))
'ignored))
(define (connect new-constraint)
(if (not (memq new-constraint constraints))
(set! constraints (cons new-constraint constraints)))
(if (has-value? me)
(inform-about-value new-constraint))
'done)
(define (me request)
(cond
((eq? request 'has-value?) (if informant
true
false))
((eq? request 'value) value)
((eq? request 'set-value!) set-my-value)
((eq? request 'forget) forget-my-value)
((eq? request 'connect) connect)
(else (error "Unknown operation -- CONNECTOR" request))))
me))
(define (for-each-except exception procedure list)
(define (loop items)
(cond
((null? items) 'done)
((eq? (car items) exception) (loop (cdr items)))
(else (procedure (car items)) (loop (cdr items)))))
(loop list))
(define (has-value? connector)
(connector 'has-value?))
(define (get-value connector)
(connector 'value))
(define (set-value! connector new-value informant)
((connector 'set-value!) new-value informant))
(define (forget-value! connector retractor)
((connector 'forget) retractor))
(define (connect connector new-constraint)
((connector 'connect) new-constraint))
(define (celsius-fahrenheit-converter c f)
(let ((u (make-connector))
(v (make-connector))
(w (make-connector))
(x (make-connector))
(y (make-connector)))
(multiplier c w u)
(multiplier v x u)
(adder v y f)
(constant 9 w)
(constant 5 x)
(constant 32 y)
'ok))
(define (adder a1 a2 sum)
(define (process-new-value)
(cond
((and (has-value? a1) (has-value? a2))
(set-value! sum (+ (get-value a1) (get-value a2)) me))
((and (has-value? a1) (has-value? sum))
(set-value! a2 (- (get-value sum) (get-value a1)) me))
((and (has-value? a2) (has-value? sum))
(set-value! a1 (- (get-value sum) (get-value a2)) me))))
(define (process-forget-value)
(forget-value! sum me)
(forget-value! a1 me)
(forget-value! a2 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 -- ADDER" request))))
(connect a1 me)
(connect a2 me)
(connect sum me)
me)
(define C (make-connector))
(define F (make-connector))
(celsius-fahrenheit-converter C F)
(probe "Celsius temp" C)
(probe "Fahrenheit temp" F)
;(set-value! C 25 'user)
;(set-value! F 212 'user)
;(forget-value! C 'user)
;(set-value! F 212 'user)
;; exercise 3.33 c= average(a, b)
;; 2c = a + b
(define (averager a b c)
(let ((two (make-connector))
(total (make-connector)))
(multiplier two c total)
(adder a b total)
(constant 2 two)
'ok))
(define A1 (make-connector))
(define A2 (make-connector))
(define A3 (make-connector))
(probe "A1" A1)
(probe "A2" A2)
(probe "A3" A3)
(averager A1 A2 A3)
(set-value! A1 3 'user)
(set-value! A2 5 'user)
(get-value A3)
;; exercise 3.34
;; this approach isnt a relation, it only works in one direction. if you specify the
;; squared value it will not fill inthe squareroot, since multiplier needs two inputs
;; before it will propogate the constraint.
(define (squarer-wrong a b)
(multiplier a a b))
(define va (make-connector))
(define vb (make-connector))
(squarer-wrong va vb)
(probe "va" va)
(probe "vb" vb)
(set-value! vb 25 'user)
;; exercise 3.35 squareroot
(define (squarer a b)
(define (square x)
(* x x))
(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 (square (get-value a)) me))))
(define (process-forget-value)
(forget-value! a me)
(forget-value! b 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)
(define vc (make-connector))
(define vd (make-connector))
(squarer vc vd)
(probe "vc" vc)
(probe "vd" vd)
(set-value! vd 25 'user)
(forget-value! vd 'user)
(set-value! vc 7 'user)
;; exercise 3.36 needs a diagram
;; exercise 3.37, expression syntax
(define (celsius-fahrenheit-converter x)
(c+ (c* (c/ (cv 9) (cv 5)) x) (cv 32)))
(define C (make-connector))
(define F (celsius-fahrenheit-converter C))
(define (c+ x y)
(let ((z (make-connector)))
(adder x y z)
z))
(define (c* x y)
(let ((z (make-connector)))
(multiplier x y z)
z))
(define (c/ x y)
(let ((z (make-connector)))
(multiplier z y x)
z))
(define (cv v)
(let ((z (make-connector)))
(constant v z)
z))
(celsius-fahrenheit-converter C F)
(probe "Celsius temp" C)
(probe "Fahrenheit temp" F)
(set-value! C 25 'user)
;(set-value! F 77 'user)
(forget-value! C 'user)
(set-value! F 212 'user)
;; footnote 33 is very interesting, they discuss how the imperative style is cumbersome,
;; but it is straightforward to move to expression oriented and
;; not the other way. they also bring up vectorization, if you can
;; return procedures than you can avoid temporary variables.
;; this is pretty important, compilers do a good job of this when they are single variables but much less so for vectors.
;; also vectorizing often brings up data flow, which often has to be done explicitly by the programmer, even though the vectorized expression is often compleely data parallel.
;; this should be interesting in the coming chapter on concurrency.
;;;
;;;
;;;
;;;
;;;
;;;
| false |
8a7ace2accf610ae7220bfc5d8d74fd385a3c00d
|
bebaa8295104ecb86fcc5becf34bfa92dd8b46fa
|
/homework/templates/hw0-1.scm
|
b4fc75a34426ef3192763a208ef1e490a2f865ce
|
[] |
no_license
|
labria/cs61a
|
65fa1570c886bd0394d66ac4f613577b8be1a64c
|
40df0351622a1afaae0da124ccf65b067e4ef66b
|
refs/heads/master
| 2020-04-03T01:41:33.372301 | 2018-10-24T12:07:19 | 2018-10-24T12:07:19 | 154,937,447 | 7 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 392 |
scm
|
hw0-1.scm
|
;; Exercise 0 - Introduce yourself
;; Make a followup on the "Hello World!" post on Piazza introducing yourself.
;; Exercise 1 - Define sum-of-squares
(define (square x) (* x x))
;; Exercise 2a - Define can-drive
;; Exercise 2b - Define fizzbuzz
;; Exercise 3 - Why did the Walrus cross the Serengeti?
#|
Your answer here
|#
;; Exercise 4 - new-if vs if
#|
Your answer here
|#
| false |
84e4f4ec7020a386d0c122e221372517006f15b0
|
120324bbbf63c54de0b7f1ca48d5dcbbc5cfb193
|
/packages/slib/formatst.scm
|
28d656aa09de5005742d08c46d681dec8c2b1a37
|
[
"MIT"
] |
permissive
|
evilbinary/scheme-lib
|
a6d42c7c4f37e684c123bff574816544132cb957
|
690352c118748413f9730838b001a03be9a6f18e
|
refs/heads/master
| 2022-06-22T06:16:56.203827 | 2022-06-16T05:54:54 | 2022-06-16T05:54:54 | 76,329,726 | 609 | 71 |
MIT
| 2022-06-16T05:54:55 | 2016-12-13T06:27:36 |
Scheme
|
UTF-8
|
Scheme
| false | false | 22,335 |
scm
|
formatst.scm
|
;; "formatst.scm" SLIB FORMAT Version 3.0 conformance test
; Written by Dirk Lutzebaeck ([email protected])
;
; This code is in the public domain.
;; Test run: (slib:load "formatst")
; Failure reports for various scheme interpreters:
;
; SCM4d
; None.
; Elk 2.2:
; None.
; MIT C-Scheme 7.1:
; The empty list is always evaluated as a boolean and consequently
; represented as `#f'.
; Scheme->C 01nov91:
; None, if format:symbol-case-conv and format:iobj-case-conv are set
; to string-downcase.
(require 'format)
(if (not (string=? format:version "3.1"))
(begin
(display "You have format version ")
(display format:version)
(display ". This test is for format version 3.0!")
(newline)
(format:abort)))
(define fails 0)
(define total 0)
(define test-verbose #f) ; shows each test performed
(define (test format-args out-str)
(set! total (+ total 1))
(if (not test-verbose)
(if (zero? (modulo total 10))
(begin
(display total)
(display ",")
(force-output (current-output-port)))))
(let ((format-out (apply format `(#f ,@format-args))))
(if (string=? out-str format-out)
(if test-verbose
(begin
(display "Verified ")
(write format-args)
(display " returns ")
(write out-str)
(newline)))
(begin
(set! fails (+ fails 1))
(if (not test-verbose) (newline))
(display "*Failed* ")
(write format-args)
(newline)
(display " returns ")
(write format-out)
(newline)
(display " expected ")
(write out-str)
(newline)))))
; ensure format default configuration
;;(set! format:symbol-case-conv #f)
;;(set! format:iobj-case-conv #f)
;;(set! format:iteration-bounded #t)
;;(set! format:max-iterations 100)
(format #t "~q")
(format #t "This implementation has~@[ no~] flonums ~
~:[but no~;and~] complex numbers~%"
(not format:floats) format:complex-numbers)
; any object test
(test '("abc") "abc")
(test '("~a" 10) "10")
(test '("~a" -1.2) "-1.2")
(test '("~a" a) "a")
(test '("~a" #t) "#t")
(test '("~a" #f) "#f")
(test '("~a" "abc") "abc")
(test '("~a" #(1 2 3)) "#(1 2 3)")
(test '("~a" ()) "()")
(test '("~a" (a)) "(a)")
(test '("~a" (a b)) "(a b)")
(test '("~a" (a (b c) d)) "(a (b c) d)")
(test '("~a" (a . b)) "(a . b)")
(test '("~a" (a (b c . d))) "(a (b . (c . d)))") ; this is ugly
(test `("~a" ,display) (format:iobj->str display #f))
(test `("~a" ,(current-input-port)) (format:iobj->str (current-input-port) #f))
(test `("~a" ,(current-output-port)) (format:iobj->str (current-output-port) #f))
; # argument test
(test '("~a ~a" 10 20) "10 20")
(test '("~a abc ~a def" 10 20) "10 abc 20 def")
; numerical test
(test '("~d" 100) "100")
(test '("~x" 100) "64")
(test '("~o" 100) "144")
(test '("~b" 100) "1100100")
(test '("~@d" 100) "+100")
(test '("~@d" -100) "-100")
(test '("~@x" 100) "+64")
(test '("~@o" 100) "+144")
(test '("~@b" 100) "+1100100")
(test '("~10d" 100) " 100")
(test '("~:d" 123) "123")
(test '("~:d" 1234) "1,234")
(test '("~:d" 12345) "12,345")
(test '("~:d" 123456) "123,456")
(test '("~:d" 12345678) "12,345,678")
(test '("~:d" -123) "-123")
(test '("~:d" -1234) "-1,234")
(test '("~:d" -12345) "-12,345")
(test '("~:d" -123456) "-123,456")
(test '("~:d" -12345678) "-12,345,678")
(test '("~10:d" 1234) " 1,234")
(test '("~10:d" -1234) " -1,234")
(test '("~10,'*d" 100) "*******100")
(test '("~10,,'|:d" 12345678) "12|345|678")
(test '("~10,,,2:d" 12345678) "12,34,56,78")
(test '("~14,'*,'|,4:@d" 12345678) "****+1234|5678")
(test '("~10r" 100) "100")
(test '("~2r" 100) "1100100")
(test '("~8r" 100) "144")
(test '("~16r" 100) "64")
(test '("~16,10,'*r" 100) "********64")
; roman numeral test
(test '("~@r" 4) "IV")
(test '("~@r" 19) "XIX")
(test '("~@r" 50) "L")
(test '("~@r" 100) "C")
(test '("~@r" 1000) "M")
(test '("~@r" 99) "XCIX")
(test '("~@r" 1994) "MCMXCIV")
; old roman numeral test
(test '("~:@r" 4) "IIII")
(test '("~:@r" 5) "V")
(test '("~:@r" 10) "X")
(test '("~:@r" 9) "VIIII")
; cardinal/ordinal English number test
(test '("~r" 4) "four")
(test '("~r" 10) "ten")
(test '("~r" 19) "nineteen")
(test '("~r" 1984) "one thousand, nine hundred eighty-four")
(test '("~:r" -1984) "minus one thousand, nine hundred eighty-fourth")
; character test
(test '("~c" #\a) "a")
(test '("~@c" #\a) "#\\a")
(test `("~@c" ,(integer->char 32)) "#\\space")
(test `("~@c" ,(integer->char 0)) "#\\nul")
(test `("~@c" ,(integer->char 27)) "#\\esc")
(test `("~@c" ,(integer->char 127)) "#\\del")
(test `("~@c" ,(integer->char 128)) "#\\200")
(test `("~@c" ,(integer->char 255)) "#\\377")
(test '("~65c") "A")
(test '("~7@c") "#\\bel")
(test '("~:c" #\a) "a")
(test `("~:c" ,(integer->char 1)) "^A")
(test `("~:c" ,(integer->char 27)) "^[")
(test '("~7:c") "^G")
(test `("~:c" ,(integer->char 128)) "#\\200")
(test `("~:c" ,(integer->char 127)) "#\\177")
(test `("~:c" ,(integer->char 255)) "#\\377")
; plural test
(test '("test~p" 1) "test")
(test '("test~p" 2) "tests")
(test '("test~p" 0) "tests")
(test '("tr~@p" 1) "try")
(test '("tr~@p" 2) "tries")
(test '("tr~@p" 0) "tries")
(test '("~a test~:p" 10) "10 tests")
(test '("~a test~:p" 1) "1 test")
; tilde test
(test '("~~~~") "~~")
(test '("~3~") "~~~")
; whitespace character test
(test '("~%") "
")
(test '("~3%") "
")
(test '("~&") "")
(test '("abc~&") "abc
")
(test '("abc~&def") "abc
def")
(test '("~&") "
")
(test '("~3&") "
")
(test '("abc~3&") "abc
")
(test '("~|") (string slib:form-feed))
(test '("~_~_~_") " ")
(test '("~3_") " ")
(test '("~/") (string slib:tab))
(test '("~3/") (make-string 3 slib:tab))
; tabulate test
(test '("~0&~3t") " ")
(test '("~0&~10t") " ")
(test '("~10t") "")
(test '("~0&1234567890~,8tABC") "1234567890 ABC")
(test '("~0&1234567890~0,8tABC") "1234567890 ABC")
(test '("~0&1234567890~1,8tABC") "1234567890 ABC")
(test '("~0&1234567890~2,8tABC") "1234567890ABC")
(test '("~0&1234567890~3,8tABC") "1234567890 ABC")
(test '("~0&1234567890~4,8tABC") "1234567890 ABC")
(test '("~0&1234567890~5,8tABC") "1234567890 ABC")
(test '("~0&1234567890~6,8tABC") "1234567890 ABC")
(test '("~0&1234567890~7,8tABC") "1234567890 ABC")
(test '("~0&1234567890~8,8tABC") "1234567890 ABC")
(test '("~0&1234567890~9,8tABC") "1234567890 ABC")
(test '("~0&1234567890~10,8tABC") "1234567890ABC")
(test '("~0&1234567890~11,8tABC") "1234567890 ABC")
(test '("~0&12345~,8tABCDE~,8tXYZ") "12345 ABCDE XYZ")
(test '("~,8t+++~,8t===") " +++ ===")
(test '("~0&ABC~,8,'.tDEF") "ABC......DEF")
(test '("~0&~3,8@tABC") " ABC")
(test '("~0&1234~3,8@tABC") "1234 ABC")
(test '("~0&12~3,8@tABC~3,8@tDEF") "12 ABC DEF")
; indirection test
(test '("~a ~? ~a" 10 "~a ~a" (20 30) 40) "10 20 30 40")
(test '("~a ~@? ~a" 10 "~a ~a" 20 30 40) "10 20 30 40")
; field test
(test '("~10a" "abc") "abc ")
(test '("~10@a" "abc") " abc")
(test '("~10a" "0123456789abc") "0123456789abc")
(test '("~10@a" "0123456789abc") "0123456789abc")
; pad character test
(test '("~10,,,'*a" "abc") "abc*******")
(test '("~10,,,'Xa" "abc") "abcXXXXXXX")
(test '("~10,,,42a" "abc") "abc*******")
(test '("~10,,,'*@a" "abc") "*******abc")
(test '("~10,,3,'*a" "abc") "abc*******")
(test '("~10,,3,'*a" "0123456789abc") "0123456789abc***") ; min. padchar length
(test '("~10,,3,'*@a" "0123456789abc") "***0123456789abc")
; colinc, minpad padding test
(test '("~10,8,0,'*a" 123) "123********")
(test '("~10,9,0,'*a" 123) "123*********")
(test '("~10,10,0,'*a" 123) "123**********")
(test '("~10,11,0,'*a" 123) "123***********")
(test '("~8,1,0,'*a" 123) "123*****")
(test '("~8,2,0,'*a" 123) "123******")
(test '("~8,3,0,'*a" 123) "123******")
(test '("~8,4,0,'*a" 123) "123********")
(test '("~8,5,0,'*a" 123) "123*****")
(test '("~8,1,3,'*a" 123) "123*****")
(test '("~8,1,5,'*a" 123) "123*****")
(test '("~8,1,6,'*a" 123) "123******")
(test '("~8,1,9,'*a" 123) "123*********")
; slashify test
(test '("~s" "abc") "\"abc\"")
(test '("~s" "abc \\ abc") "\"abc \\\\ abc\"")
(test '("~a" "abc \\ abc") "abc \\ abc")
(test '("~s" "abc \" abc") "\"abc \\\" abc\"")
(test '("~a" "abc \" abc") "abc \" abc")
(test '("~s" #\space) "#\\space")
(test '("~s" #\newline) "#\\newline")
(test `("~s" ,slib:tab) "#\\ht")
(test '("~s" #\a) "#\\a")
(test '("~a" (a "b" c)) "(a \"b\" c)")
; symbol case force test
(define format:old-scc format:symbol-case-conv)
(set! format:symbol-case-conv string-upcase)
(test '("~a" abc) "ABC")
(set! format:symbol-case-conv string-downcase)
(test '("~s" abc) "abc")
(set! format:symbol-case-conv string-capitalize)
(test '("~s" abc) "Abc")
(set! format:symbol-case-conv format:old-scc)
; read proof test
(test `("~:s" ,display) (format:iobj->str display #t))
(test `("~:a" ,display) (format:iobj->str display #t))
(test `("~:a" (1 2 ,display)) (string-append "(1 2 " (format:iobj->str display #t) ")"))
(test '("~:a" "abc") "abc")
; internal object case type force test
(set! format:iobj-case-conv string-upcase)
(test `("~a" ,display) (string-upcase (format:iobj->str display #f)))
(set! format:iobj-case-conv string-downcase)
(test `("~s" ,display) (string-downcase (format:iobj->str display #f)))
(set! format:iobj-case-conv string-capitalize)
(test `("~s" ,display) (string-capitalize (format:iobj->str display #f)))
(set! format:iobj-case-conv #f)
; continuation line test
(test '("abc~
123") "abc123")
(test '("abc~
123") "abc123")
(test '("abc~
") "abc")
(test '("abc~:
def") "abc def")
(test '("abc~@
def")
"abc
def")
; flush output (can't test it here really)
(test '("abc ~! xyz") "abc xyz")
; string case conversion
(test '("~a ~(~a~) ~a" "abc" "HELLO WORLD" "xyz") "abc hello world xyz")
(test '("~a ~:(~a~) ~a" "abc" "HELLO WORLD" "xyz") "abc Hello World xyz")
(test '("~a ~@(~a~) ~a" "abc" "HELLO WORLD" "xyz") "abc Hello world xyz")
(test '("~a ~:@(~a~) ~a" "abc" "hello world" "xyz") "abc HELLO WORLD xyz")
(test '("~:@(~a~)" (a b c)) "(A B C)")
(test '("~:@(~x~)" 255) "FF")
(test '("~:@(~p~)" 2) "S")
(test `("~:@(~a~)" ,display) (string-upcase (format:iobj->str display #f)))
(test '("~:(~a ~a ~a~) ~a" "abc" "xyz" "123" "world") "Abc Xyz 123 world")
; variable parameter
(test '("~va" 10 "abc") "abc ")
(test '("~v,,,va" 10 42 "abc") "abc*******")
; number of remaining arguments as parameter
(test '("~#,,,'*@a ~a ~a ~a" 1 1 1 1) "***1 1 1 1")
; argument jumping
(test '("~a ~* ~a" 10 20 30) "10 30")
(test '("~a ~2* ~a" 10 20 30 40) "10 40")
(test '("~a ~:* ~a" 10) "10 10")
(test '("~a ~a ~2:* ~a ~a" 10 20) "10 20 10 20")
(test '("~a ~a ~@* ~a ~a" 10 20) "10 20 10 20")
(test '("~a ~a ~4@* ~a ~a" 10 20 30 40 50 60) "10 20 50 60")
; conditionals
(test '("~[abc~;xyz~]" 0) "abc")
(test '("~[abc~;xyz~]" 1) "xyz")
(test '("~[abc~;xyz~:;456~]" 99) "456")
(test '("~0[abc~;xyz~:;456~]") "abc")
(test '("~1[abc~;xyz~:;456~] ~a" 100) "xyz 100")
(test '("~#[no arg~;~a~;~a and ~a~;~a, ~a and ~a~]") "no arg")
(test '("~#[no arg~;~a~;~a and ~a~;~a, ~a and ~a~]" 10) "10")
(test '("~#[no arg~;~a~;~a and ~a~;~a, ~a and ~a~]" 10 20) "10 and 20")
(test '("~#[no arg~;~a~;~a and ~a~;~a, ~a and ~a~]" 10 20 30) "10, 20 and 30")
(test '("~:[hello~;world~] ~a" #t 10) "world 10")
(test '("~:[hello~;world~] ~a" #f 10) "hello 10")
(test '("~@[~a tests~]" #f) "")
(test '("~@[~a tests~]" 10) "10 tests")
(test '("~@[~a test~:p~] ~a" 10 done) "10 tests done")
(test '("~@[~a test~:p~] ~a" 1 done) "1 test done")
(test '("~@[~a test~:p~] ~a" 0 done) "0 tests done")
(test '("~@[~a test~:p~] ~a" #f done) " done")
(test '("~@[ level = ~d~]~@[ length = ~d~]" #f 5) " length = 5")
(test '("~[abc~;~[4~;5~;6~]~;xyz~]" 0) "abc") ; nested conditionals (irrghh)
(test '("~[abc~;~[4~;5~;6~]~;xyz~]" 2) "xyz")
(test '("~[abc~;~[4~;5~;6~]~;xyz~]" 1 2) "6")
; iteration
(test '("~{ ~a ~}" (a b c)) " a b c ")
(test '("~{ ~a ~}" ()) "")
(test '("~{ ~a ~5,,,'*a~}" (a b c d)) " a b**** c d****")
(test '("~{ ~a,~a ~}" (a 1 b 2 c 3)) " a,1 b,2 c,3 ")
(test '("~2{ ~a,~a ~}" (a 1 b 2 c 3)) " a,1 b,2 ")
(test '("~3{~a ~} ~a" (a b c d e) 100) "a b c 100")
(test '("~0{~a ~} ~a" (a b c d e) 100) " 100")
(test '("~:{ ~a,~a ~}" ((a b) (c d e f) (g h))) " a,b c,d g,h ")
(test '("~2:{ ~a,~a ~}" ((a b) (c d e f) (g h))) " a,b c,d ")
(test '("~@{ ~a,~a ~}" a 1 b 2 c 3) " a,1 b,2 c,3 ")
(test '("~2@{ ~a,~a ~} <~a|~a>" a 1 b 2 c 3) " a,1 b,2 <c|3>")
(test '("~:@{ ~a,~a ~}" (a 1) (b 2) (c 3)) " a,1 b,2 c,3 ")
(test '("~2:@{ ~a,~a ~} ~a" (a 1) (b 2) (c 3)) " a,1 b,2 (c 3)")
(test '("~{~}" "<~a,~a>" (a 1 b 2 c 3)) "<a,1><b,2><c,3>")
(test '("~{ ~a ~{<~a>~}~} ~a" (a (1 2) b (3 4)) 10) " a <1><2> b <3><4> 10")
(let ((nums (let iter ((ns '()) (l 0))
(if (> l 105) (reverse ns) (iter (cons l ns) (+ l 1))))))
;; Test default, only 100 items formatted out:
(test `("~D~{, ~D~}" ,(car nums) ,(cdr nums))
"0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100")
;; Test control of number of items formatted out:
(set! format:max-iterations 90)
(test `("~D~{, ~D~}" ,(car nums) ,(cdr nums))
"0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90")
;; Test control of imposing bound on number of items formatted out:
(set! format:iteration-bounded #f)
(test `("~D~{, ~D~}" ,(car nums) ,(cdr nums))
"0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105")
;; Restore defaults:
(set! format:iteration-bounded #t)
(set! format:max-iterations 100)
)
; up and out
(test '("abc ~^ xyz") "abc ")
(test '("~@(abc ~^ xyz~) ~a" 10) "ABC xyz 10")
(test '("done. ~^ ~d warning~:p. ~^ ~d error~:p.") "done. ")
(test '("done. ~^ ~d warning~:p. ~^ ~d error~:p." 10) "done. 10 warnings. ")
(test '("done. ~^ ~d warning~:p. ~^ ~d error~:p." 10 1)
"done. 10 warnings. 1 error.")
(test '("~{ ~a ~^<~a>~} ~a" (a b c d e f) 10) " a <b> c <d> e <f> 10")
(test '("~{ ~a ~^<~a>~} ~a" (a b c d e) 10) " a <b> c <d> e 10")
(test '("abc~0^ xyz") "abc")
(test '("abc~9^ xyz") "abc xyz")
(test '("abc~7,4^ xyz") "abc xyz")
(test '("abc~7,7^ xyz") "abc")
(test '("abc~3,7,9^ xyz") "abc")
(test '("abc~8,7,9^ xyz") "abc xyz")
(test '("abc~3,7,5^ xyz") "abc xyz")
; complexity tests (oh my god, I hardly understand them myself (see CL std))
(define fmt "Items:~#[ none~; ~a~; ~a and ~a~:;~@{~#[~; and~] ~a~^,~}~].")
(test `(,fmt ) "Items: none.")
(test `(,fmt foo) "Items: foo.")
(test `(,fmt foo bar) "Items: foo and bar.")
(test `(,fmt foo bar baz) "Items: foo, bar, and baz.")
(test `(,fmt foo bar baz zok) "Items: foo, bar, baz, and zok.")
; fixed floating points
(cond
(format:floats
(test '("~6,2f" 3.14159) " 3.14")
(test '("~6,1f" 3.14159) " 3.1")
(test '("~6,0f" 3.14159) " 3.")
(test '("~5,1f" 0) " 0.0")
(test '("~10,7f" 3.14159) " 3.1415900")
(test '("~10,7f" -3.14159) "-3.1415900")
(test '("~10,7@f" 3.14159) "+3.1415900")
(test '("~6,3f" 0.0) " 0.000")
(test '("~6,4f" 0.007) "0.0070")
(test '("~6,3f" 0.007) " 0.007")
(test '("~6,2f" 0.007) " 0.01")
(test '("~3,2f" 0.007) ".01")
(test '("~3,2f" -0.007) "-.01")
(test '("~6,2,,,'*f" 3.14159) "**3.14")
(test '("~6,3,,'?f" 12345.56789) "??????")
(test '("~6,3f" 12345.6789) "12345.679")
(test '("~,3f" 12345.6789) "12345.679")
(test '("~,3f" 9.9999) "10.000")
(test '("~6f" 23.4) " 23.4")
(test '("~6f" 1234.5) "1234.5")
(test '("~6f" 12345678) "12345678.0")
(test '("~6,,,'?f" 12345678) "??????")
(test '("~6f" 123.56789) "123.57")
(test '("~6f" 123.0) " 123.0")
(test '("~6f" -123.0) "-123.0")
(test '("~6f" 0.0) " 0.0")
(test '("~3f" 3.141) "3.1")
(test '("~2f" 3.141) "3.")
(test '("~1f" 3.141) "3.141")
(test '("~f" 123.56789) "123.56789")
(test '("~f" -314.0) "-314.0")
(test '("~f" 1e4) "10000.0")
(test '("~f" -1.23e10) "-12300000000.0")
(test '("~f" 1e-4) "0.0001")
(test '("~f" -1.23e-10) "-0.000000000123")
(test '("~@f" 314.0) "+314.0")
(test '("~,,3f" 0.123456) "123.456")
(test '("~,,-3f" -123.456) "-0.123456")
(test '("~5,,3f" 0.123456) "123.5")
))
; exponent floating points
(cond
(format:floats
(test '("~e" 3.14159) "3.14159E+0")
(test '("~e" 0.00001234) "1.234E-5")
(test '("~,,,0e" 0.00001234) "0.1234E-4")
(test '("~,3e" 3.14159) "3.142E+0")
(test '("~,3@e" 3.14159) "+3.142E+0")
(test '("~,3@e" 0.0) "+0.000E+0")
(test '("~,0e" 3.141) "3.E+0")
(test '("~,3,,0e" 3.14159) "0.314E+1")
(test '("~,5,3,-2e" 3.14159) "0.00314E+003")
(test '("~,5,3,-5e" -3.14159) "-0.00000E+006")
(test '("~,5,2,2e" 3.14159) "31.4159E-01")
(test '("~,5,2,,,,'ee" 0.0) "0.00000e+00")
(test '("~12,3e" -3.141) " -3.141E+0")
(test '("~12,3,,,,'#e" -3.141) "###-3.141E+0")
(test '("~10,2e" -1.236e-4) " -1.24E-4")
(test '("~5,3e" -3.141) "-3.141E+0")
(test '("~5,3,,,'*e" -3.141) "*****")
(test '("~3e" 3.14159) "3.14159E+0")
(test '("~4e" 3.14159) "3.14159E+0")
(test '("~5e" 3.14159) "3.E+0")
(test '("~5,,,,'*e" 3.14159) "3.E+0")
(test '("~6e" 3.14159) "3.1E+0")
(test '("~7e" 3.14159) "3.14E+0")
(test '("~7e" -3.14159) "-3.1E+0")
(test '("~8e" 3.14159) "3.142E+0")
(test '("~9e" 3.14159) "3.1416E+0")
(test '("~9,,,,,,'ee" 3.14159) "3.1416e+0")
(test '("~10e" 3.14159) "3.14159E+0")
(test '("~11e" 3.14159) " 3.14159E+0")
(test '("~12e" 3.14159) " 3.14159E+0")
(test '("~13,6,2,-5e" 3.14159) " 0.000003E+06")
(test '("~13,6,2,-4e" 3.14159) " 0.000031E+05")
(test '("~13,6,2,-3e" 3.14159) " 0.000314E+04")
(test '("~13,6,2,-2e" 3.14159) " 0.003142E+03")
(test '("~13,6,2,-1e" 3.14159) " 0.031416E+02")
(test '("~13,6,2,0e" 3.14159) " 0.314159E+01")
(test '("~13,6,2,1e" 3.14159) " 3.141590E+00")
(test '("~13,6,2,2e" 3.14159) " 31.41590E-01")
(test '("~13,6,2,3e" 3.14159) " 314.1590E-02")
(test '("~13,6,2,4e" 3.14159) " 3141.590E-03")
(test '("~13,6,2,5e" 3.14159) " 31415.90E-04")
(test '("~13,6,2,6e" 3.14159) " 314159.0E-05")
(test '("~13,6,2,7e" 3.14159) " 3141590.E-06")
(test '("~13,6,2,8e" 3.14159) "31415900.E-07")
(test '("~7,3,,-2e" 0.001) ".001E+0")
(test '("~8,3,,-2@e" 0.001) "+.001E+0")
(test '("~8,3,,-2@e" -0.001) "-.001E+0")
(test '("~8,3,,-2e" 0.001) "0.001E+0")
(test '("~7,,,-2e" 0.001) "0.00E+0")
(test '("~12,3,1e" 3.14159e12) " 3.142E+12")
(test '("~12,3,1,,'*e" 3.14159e12) "************")
(test '("~5,3,1e" 3.14159e12) "3.142E+12")
))
; general floating point (this test is from Steele's CL book)
(cond
(format:floats
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
0.0314159 0.0314159 0.0314159 0.0314159)
" 3.14E-2|314.2$-04|0.314E-01| 3.14E-2")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
0.314159 0.314159 0.314159 0.314159)
" 0.31 |0.314 |0.314 | 0.31 ")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
3.14159 3.14159 3.14159 3.14159)
" 3.1 | 3.14 | 3.14 | 3.1 ")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
31.4159 31.4159 31.4159 31.4159)
" 31. | 31.4 | 31.4 | 31. ")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
314.159 314.159 314.159 314.159)
" 3.14E+2| 314. | 314. | 3.14E+2")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
3141.59 3141.59 3141.59 3141.59)
" 3.14E+3|314.2$+01|0.314E+04| 3.14E+3")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
3.14E12 3.14E12 3.14E12 3.14E12)
"*********|314.0$+10|0.314E+13| 3.14E+12")
(test '("~9,2,1,,'*g|~9,3,2,3,'?,,'$g|~9,3,2,0,'%g|~9,2g"
3.14E120 3.14E120 3.14E120 3.14E120)
"*********|?????????|%%%%%%%%%|3.14E+120")
(test '("~g" 0.0) "0.0 ") ; further ~g tests
(test '("~g" 0.1) "0.1 ")
(test '("~g" 0.01) "1.0E-2")
(test '("~g" 123.456) "123.456 ")
(test '("~g" 123456.7) "123456.7 ")
(test '("~g" 123456.78) "123456.78 ")
(test '("~g" 0.9282) "0.9282 ")
(test '("~g" 0.09282) "9.282E-2")
(test '("~g" 1) "1.0 ")
(test '("~g" 12) "12.0 ")
))
; dollar floating point
(cond
(format:floats
(test '("~$" 1.23) "1.23")
(test '("~$" 1.2) "1.20")
(test '("~$" 0.0) "0.00")
(test '("~$" 9.999) "10.00")
(test '("~3$" 9.9999) "10.000")
(test '("~,4$" 3.2) "0003.20")
(test '("~,4$" 10000.2) "10000.20")
(test '("~,4,10$" 3.2) " 0003.20")
(test '("~,4,10@$" 3.2) " +0003.20")
(test '("~,4,10:@$" 3.2) "+ 0003.20")
(test '("~,4,10:$" -3.2) "- 0003.20")
(test '("~,4,10$" -3.2) " -0003.20")
(test '("~,,10@$" 3.2) " +3.20")
(test '("~,,10:@$" 3.2) "+ 3.20")
(test '("~,,10:@$" -3.2) "- 3.20")
(test '("~,,10,'_@$" 3.2) "_____+3.20")
(test '("~,,4$" 1234.4) "1234.40")
))
; complex numbers
(cond
(format:complex-numbers
(test '("~i" 3.0) "3.0+0.0i")
(test '("~,3i" 3.0) "3.000+0.000i")
(test `("~7,2i" ,(string->number "3.0+5.0i")) " 3.00 +5.00i")
(test `("~7,2,1i" ,(string->number "3.0+5.0i")) " 30.00 +50.00i")
(test `("~7,2@i" ,(string->number "3.0+5.0i")) " +3.00 +5.00i")
(test `("~7,2,,,'*@i" ,(string->number "3.0+5.0i")) "**+3.00**+5.00i")
)) ; note: some parsers choke syntactically on reading a complex
; number though format:complex is #f; this is why we put them in
; strings
; inquiry test
(test '("~:q") format:version)
(if (not test-verbose) (display "done."))
(format #t "~%~a Test~:p completed. (~a failure~:p)~2%" total fails)
| false |
406ab8563f008b729d6930d3dc25a893b4043d14
|
f59b3ca0463fed14792de2445de7eaaf66138946
|
/section-3/3_44.scm
|
157fb2bc1491e10c05a3f5041af685b9f3c56bd9
|
[] |
no_license
|
uryu1994/sicp
|
f903db275f6f8c2da0a6c0d9a90c0c1cf8b1e718
|
b14c728bc3351814ff99ace3b8312a651f788e6c
|
refs/heads/master
| 2020-04-12T01:34:28.289074 | 2018-06-26T15:17:06 | 2018-06-26T15:17:06 | 58,478,460 | 0 | 1 | null | 2018-06-20T11:32:33 | 2016-05-10T16:53:00 |
Scheme
|
UTF-8
|
Scheme
| false | false | 383 |
scm
|
3_44.scm
|
(define (transfer from-account to-account amount)
((from-account 'withdraw) amount)
((to-account 'deposit) amount))
;; 正しくない
;; 移動(transfer): 預け入れ・引き出しの順番は前後しても結果は同じ
;; 交換(exchange): 「残高取得」->「預け入れ・引き出し」この順番は前後することはできない(serializeする必要あり)
| false |
791173ad1176ae4c18932723d1669f5281823841
|
b9eb119317d72a6742dce6db5be8c1f78c7275ad
|
/random-scheme-stuff/return.scm
|
286c8dc4f55376b771d7dac8e6df21fd6def4f72
|
[] |
no_license
|
offby1/doodles
|
be811b1004b262f69365d645a9ae837d87d7f707
|
316c4a0dedb8e4fde2da351a8de98a5725367901
|
refs/heads/master
| 2023-02-21T05:07:52.295903 | 2022-05-15T18:08:58 | 2022-05-15T18:08:58 | 512,608 | 2 | 1 | null | 2023-02-14T22:19:40 | 2010-02-11T04:24:52 |
Scheme
|
UTF-8
|
Scheme
| false | false | 1,165 |
scm
|
return.scm
|
;; The old-fasioned way
(let ((inner-calls 0)
(found #f))
(let loop ((x 100))
(if (and
(not (zero? x))
(not found))
(begin
(let loop ((y 100))
(if (and
(not (zero? y))
(not found))
(begin
(if (and (= x 50)
(= y 50))
(set! found #t)
(begin
(set! inner-calls (+ 1 inner-calls))
(loop (- y 1)))))))
(loop (- x 1)))))
inner-calls)
;; The Scheme way
(call-with-current-continuation
(lambda (return)
(let ((inner-calls 0))
(let loop ((x 100))
(if (not (zero? x))
(begin
(let loop ((y 100))
(if (not (zero? y))
(begin
(if (and (= x 50)
(= y 50))
(return inner-calls))
(set! inner-calls (+ 1 inner-calls))
(loop (- y 1)))))
(loop (- x 1))))))))
| false |
860586a8c578545d881092bd73ad8dfc3f9b016a
|
97b9e4b5623c1e3d201fa0f0e624852c276e8cc6
|
/tests-1.5-opt.scm
|
a7d44bf43b7f69d9078745dcf62ae7925d637204
|
[] |
no_license
|
seckcoder/seck-scheme
|
89556794e7834058269058569695997ead50c4b6
|
787814a2042e38762a73f126aaa03ca2702cd9db
|
refs/heads/master
| 2021-01-23T06:49:31.735249 | 2015-08-15T03:17:54 | 2015-08-15T03:17:54 | 40,744,969 | 6 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 102 |
scm
|
tests-1.5-opt.scm
|
(add-tests-with-string-output "divide"
[(quotient 100 3) => "33\n"]
[(remainder 100 3) => "1\n"])
| false |
6ca241078a2db1c4e687898d3e8f6957caba8e00
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System/system/code-dom/code-default-value-expression.sls
|
403183e0512e272d69a0a9e6768f3a885718a2ac
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 725 |
sls
|
code-default-value-expression.sls
|
(library (system code-dom code-default-value-expression)
(export new
is?
code-default-value-expression?
type-get
type-set!
type-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.CodeDom.CodeDefaultValueExpression a ...)))))
(define (is? a) (clr-is System.CodeDom.CodeDefaultValueExpression a))
(define (code-default-value-expression? a)
(clr-is System.CodeDom.CodeDefaultValueExpression a))
(define-field-port
type-get
type-set!
type-update!
(property:)
System.CodeDom.CodeDefaultValueExpression
Type
System.CodeDom.CodeTypeReference))
| true |
1beed43565e69664273de7e3854e0177c2b8b4b6
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System/system/net/network-information/ipglobal-properties.sls
|
91c2c0f8e8916ad8a010b84dd5f70e5a20301250
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,830 |
sls
|
ipglobal-properties.sls
|
(library (system net network-information ipglobal-properties)
(export is?
ipglobal-properties?
get-udp-ipv6-statistics
get-tcp-ipv6-statistics
get-ipglobal-properties
get-active-tcp-listeners
get-icmp-v4-statistics
get-ipv6-global-statistics
get-ipv4-global-statistics
get-icmp-v6-statistics
get-active-tcp-connections
get-tcp-ipv4-statistics
get-active-udp-listeners
get-udp-ipv4-statistics
dhcp-scope-name
domain-name
host-name
is-wins-proxy?
node-type)
(import (ironscheme-clr-port))
(define (is? a)
(clr-is System.Net.NetworkInformation.IPGlobalProperties a))
(define (ipglobal-properties? a)
(clr-is System.Net.NetworkInformation.IPGlobalProperties a))
(define-method-port
get-udp-ipv6-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetUdpIPv6Statistics
(System.Net.NetworkInformation.UdpStatistics))
(define-method-port
get-tcp-ipv6-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetTcpIPv6Statistics
(System.Net.NetworkInformation.TcpStatistics))
(define-method-port
get-ipglobal-properties
System.Net.NetworkInformation.IPGlobalProperties
GetIPGlobalProperties
(static: System.Net.NetworkInformation.IPGlobalProperties))
(define-method-port
get-active-tcp-listeners
System.Net.NetworkInformation.IPGlobalProperties
GetActiveTcpListeners
(System.Net.IPEndPoint[]))
(define-method-port
get-icmp-v4-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetIcmpV4Statistics
(System.Net.NetworkInformation.IcmpV4Statistics))
(define-method-port
get-ipv6-global-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetIPv6GlobalStatistics
(System.Net.NetworkInformation.IPGlobalStatistics))
(define-method-port
get-ipv4-global-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetIPv4GlobalStatistics
(System.Net.NetworkInformation.IPGlobalStatistics))
(define-method-port
get-icmp-v6-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetIcmpV6Statistics
(System.Net.NetworkInformation.IcmpV6Statistics))
(define-method-port
get-active-tcp-connections
System.Net.NetworkInformation.IPGlobalProperties
GetActiveTcpConnections
(System.Net.NetworkInformation.TcpConnectionInformation[]))
(define-method-port
get-tcp-ipv4-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetTcpIPv4Statistics
(System.Net.NetworkInformation.TcpStatistics))
(define-method-port
get-active-udp-listeners
System.Net.NetworkInformation.IPGlobalProperties
GetActiveUdpListeners
(System.Net.IPEndPoint[]))
(define-method-port
get-udp-ipv4-statistics
System.Net.NetworkInformation.IPGlobalProperties
GetUdpIPv4Statistics
(System.Net.NetworkInformation.UdpStatistics))
(define-field-port
dhcp-scope-name
#f
#f
(property:)
System.Net.NetworkInformation.IPGlobalProperties
DhcpScopeName
System.String)
(define-field-port
domain-name
#f
#f
(property:)
System.Net.NetworkInformation.IPGlobalProperties
DomainName
System.String)
(define-field-port
host-name
#f
#f
(property:)
System.Net.NetworkInformation.IPGlobalProperties
HostName
System.String)
(define-field-port
is-wins-proxy?
#f
#f
(property:)
System.Net.NetworkInformation.IPGlobalProperties
IsWinsProxy
System.Boolean)
(define-field-port
node-type
#f
#f
(property:)
System.Net.NetworkInformation.IPGlobalProperties
NodeType
System.Net.NetworkInformation.NetBiosNodeType))
| false |
e73bce2d31b0b1d07eec7421acb8890c624c9e76
|
de82217869618b0a975e86918184ecfddf701172
|
/reference/exceptions/exception-internal.scm
|
7b8b7111df59bb1fcff3637eb03595ef1462884d
|
[] |
no_license
|
schemedoc/r6rs
|
6b4ef7fd87d8883d6c4bcc422b38b37f588e20f7
|
0009085469e47df44068873f834a0d0282648750
|
refs/heads/master
| 2021-06-18T17:44:50.149253 | 2020-01-04T10:50:50 | 2020-01-04T10:50:50 | 178,081,881 | 5 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,071 |
scm
|
exception-internal.scm
|
; Reference implementation for exceptions library, adapted from SRFI 34
; Copyright (C) Richard Kelsey, Michael Sperber (2002). All Rights Reserved.
; Permission is hereby granted, free of charge, to any person
; obtaining a copy of this software and associated documentation files
; (the "Software"), to deal in the Software without restriction,
; including without limitation the rights to use, copy, modify, merge,
; publish, distribute, sublicense, and/or sell copies of the Software,
; and to permit persons to whom the Software is furnished to do so,
; subject to the following conditions:
; The above copyright notice and this permission notice shall be
; included in all copies or substantial portions of the Software.
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
; SOFTWARE.
(library (r6rs exceptions internal)
(export with-exception-handler
(guard :syntax)
raise
raise-continuable
set-operate-non-continuable!
set-operate-unhandled!)
(import (r6rs base)
;; This library is assumed to export a procedure `abort'
;; exists that takes a message and aborts the running
;; program.
(r6rs internal abort))
; This will be set later to avoid a circular dependency between
; the exceptions and the conditions libraries.
; This will take
; - a raise-like procedure
; - a symbol for &who
; - a variable number of arguments for &irritants
; It should call the raise-like procedure on a suitable condition object
(define operate-non-continuable (unspecified))
(define (set-operate-non-continuable! p)
(set! operate-non-continuable p))
; This will take
; - an abort-like procedure
; - a condition object
; It should call abort if the condition object specifies a serious condition,
; and print a message and return otherwise.
(define operate-unhandled (unspecified))
(define (set-operate-unhandled! p)
(set! operate-unhandled p))
(define *current-exception-handlers*
(list (lambda (condition)
(operate-unhandled abort
condition))))
(define (with-exception-handler handler thunk)
(with-exception-handlers (cons handler *current-exception-handlers*)
thunk))
(define (with-exception-handlers new-handlers thunk)
(let ((previous-handlers *current-exception-handlers*))
(dynamic-wind
(lambda ()
(set! *current-exception-handlers* new-handlers))
thunk
(lambda ()
(set! *current-exception-handlers* previous-handlers)))))
(define (raise obj)
(let ((handlers *current-exception-handlers*))
(with-exception-handlers (cdr handlers)
(lambda ()
((car handlers) obj)
(operate-non-continuable raise
'raise
(car handlers)
obj)))))
(define (raise-continuable obj)
(let ((handlers *current-exception-handlers*))
(with-exception-handlers (cdr handlers)
(lambda ()
((car handlers) obj)))))
(define-syntax guard
(syntax-rules ()
((guard (var clause ...) e1 e2 ...)
((call-with-current-continuation
(lambda (guard-k)
(with-exception-handler
(lambda (condition)
((call-with-current-continuation
(lambda (handler-k)
(guard-k
(lambda ()
(let ((var condition)) ; clauses may SET! var
(guard-aux (handler-k (lambda ()
(raise-continuable condition)))
clause ...))))))))
(lambda ()
(call-with-values
(lambda () e1 e2 ...)
(lambda args
(guard-k (lambda ()
(apply values args)))))))))))))
(define-syntax guard-aux
(syntax-rules (else =>)
((guard-aux reraise (else result1 result2 ...))
(begin result1 result2 ...))
((guard-aux reraise (test => result))
(let ((temp test))
(if temp
(result temp)
reraise)))
((guard-aux reraise (test => result) clause1 clause2 ...)
(let ((temp test))
(if temp
(result temp)
(guard-aux reraise clause1 clause2 ...))))
((guard-aux reraise (test))
test)
((guard-aux reraise (test) clause1 clause2 ...)
(let ((temp test))
(if temp
temp
(guard-aux reraise clause1 clause2 ...))))
((guard-aux reraise (test result1 result2 ...))
(if test
(begin result1 result2 ...)
reraise))
((guard-aux reraise (test result1 result2 ...) clause1 clause2 ...)
(if test
(begin result1 result2 ...)
(guard-aux reraise clause1 clause2 ...)))))
) ; end of library form
| true |
cb508e7c9274b679211241a6d28eb93f15440194
|
19e1e43abea015add4edaa8257602da08cadedb5
|
/glfw.scm
|
745d923f6d4789817a18f3d10568f7d15c6d5d05
|
[] |
no_license
|
corrodedlabs/phoenix
|
1f3f34d00e8426fc92b7bc814d5b640e7a8738d5
|
8a2974cc4e886a5276b7a14598c7a55642feec5a
|
refs/heads/master
| 2022-02-20T18:25:36.486934 | 2022-02-06T09:32:22 | 2022-02-06T09:32:22 | 226,878,975 | 6 | 0 | null | 2022-02-06T09:30:10 | 2019-12-09T13:33:16 |
Scheme
|
UTF-8
|
Scheme
| false | false | 5,588 |
scm
|
glfw.scm
|
(library (glfw)
(export glfw-init
glfw-get-required-instance-extensions
create-window
new-window
poll-events
get-movement-direction
movement-data
movement-data?
movement-data-forward
movement-data-back
movement-data-right
movement-data-left)
(import (chezscheme)
(ffi)
(glfw glfw))
;; (define glfw (load-shared-object "libglfw.so"))
(define glfw-init (foreign-procedure "glfwInit" () boolean))
(define-record-type window (nongenerative) (fields handle surface))
;; create glfw window also initializes glfw
(define new-window
(lambda (width height)
(glfwInit)
(glfwWindowHint GLFW_CLIENT_API GLFW_NO_API)
(glfwWindowHint GLFW_RESIZABLE GLFW_FALSE)
(glfwCreateWindow width height "Phoenix" 0 0)))
(define create-surface
(lambda (vk-instance window)
(let ((surface (make-foreign-object uptr)))
(case (glfwCreateWindowSurface (ftype-pointer-address vk-instance)
window
0
(ftype-pointer-address surface))
((0) surface)
(else (error "failed to create window surface" window))))))
;; Input Mode
;; STICKY_KEYS
;; When sticky keys mode is enabled, the pollable state of a key will remain
;; GLFW_PRESS until the state of that key is polled with glfwGetKey. Once it has been
;; polled, if a key release event had been processed in the meantime, the state will reset
;; to GLFW_RELEASE, otherwise it will remain GLFW_PRESS.
;;
;; glfwSetInputMode(window, GLFW_STICKY_KEYS, GLFW_TRUE);
;; LOCK_KEY_MODS
(define GLFW_LOCK_KEY_MODS #x00033004)
;; If you wish to know what the state of the Caps Lock and Num Lock keys was when input
;; events were generated, set the GLFW_LOCK_KEY_MODS input mode.
;;
;; glfwSetInputMode(window, GLFW_LOCK_KEY_MODS, GLFW_TRUE);
;;
;; When this input mode is enabled, any callback that receives modifier bits will have the
;; GLFW_MOD_CAPS_LOCK bit set if Caps Lock was on when the event occurred and the
;; GLFW_MOD_NUM_LOCK bit set if Num Lock was on.
;; The GLFW_KEY_LAST constant holds the highest value of any named key.
(define setup-input-mode
(lambda (window)
(glfwSetInputMode window GLFW_STICKY_KEYS GLFW_TRUE)
(glfwSetInputMode window GLFW_LOCK_KEY_MODS GLFW_TRUE)))
(define create-window
(lambda (vk-instance width height)
(let ((window (new-window width height)))
(setup-input-mode window)
(make-window window (create-surface vk-instance window)))))
;; GLFW needs to poll the window system for events both to provide input to the application
;; and to prove to the window system that the application hasn't locked up.
;; Event processing is normally done each frame after buffer swapping. Even when you have
;; no windows, event polling needs to be done in order to receive monitor and joystick
;; connection events.
;; glfwPollEvents();
;; This is the best choice when rendering continuously, like most games do.
;; There are three functions for processing pending events.
;; glfwPollEvents processes only those events that have already been received and then
;; returns immediately.
(define poll-events glfwPollEvents)
;; get-keys
;;
;; This function returns the last state reported for the specified key to the specified
;; window. The returned state is one of GLFW_PRESS or GLFW_RELEASE. The higher-level action
;; GLFW_REPEAT is only reported to the key callback.
;; If the GLFW_STICKY_KEYS input mode is enabled, this function returns GLFW_PRESS the first
;; time you call it for a key that was pressed, even if that key has already been released.
;; The key functions deal with physical keys, with key tokens named after their use on the
;; standard US keyboard layout.
;; If you want to input text, use the Unicode character callback instead.
;; The modifier key bit masks are not key tokens and cannot be used with this function.
;; Do not use this function to implement text input.
;; Parameters
;; [in] window The desired window.
;; [in] key The desired keyboard key. GLFW_KEY_UNKNOWN is not a valid key for
;; this function.
;; Returns
;; One of GLFW_PRESS or GLFW_RELEASE.
;; Errors
;; Possible errors include GLFW_NOT_INITIALIZED and GLFW_INVALID_ENUM.
;; Thread safety
;; This function must only be called from the main thread.
;; See also
;; Key input
;; Since
;; Added in version 1.0. GLFW 3: Added window handle parameter.
(define get-key glfwGetKey)
(define key-pressed?
(lambda (window key)
(equal? (get-key window key) GLFW_PRESS)))
;; record to capture the direction of movement
;; all the fields are boolean
;; this record will be enriched as and when we need to capture different commands
(define-record-type movement-data (nongenerative) (fields forward back right left))
(define get-movement-direction
(lambda (window)
(let ((forward (key-pressed? window GLFW_KEY_W))
(back (key-pressed? window GLFW_KEY_S))
(right (key-pressed? window GLFW_KEY_D))
(left (key-pressed? window GLFW_KEY_A)))
(make-movement-data forward back right left))))
(define glfw-get-required-instance-extensions
(lambda ()
(let ((f (foreign-procedure "glfwGetRequiredInstanceExtensions"
((* int)) uptr)))
(let* ((num-extensions (make-foreign-object int))
(extensions (f num-extensions)))
(cons (read-int num-extensions)
extensions))))))
#|
> (load "glfw.scm")
> (import (glfw))
> (glfw-init)
> (ptr->strings (glfw-get-required-instance-extensions))
|#
| false |
599fd7ae0762e48a15c2000508a664e4cb34469c
|
fd00d1845e52461354a1edbb28a3b7484f7da1f5
|
/Scheme/lib/nested-foof-loop.ss
|
10292de63b0c8f3870b2ca8b4c6619a060c68d6c
|
[
"ISC"
] |
permissive
|
yingted/Myro
|
81b17623e839f5f17f40bf5d6a9291b26c4dccaa
|
c7cc199631b5983213d6cbc2ae8d1e3653bb175d
|
refs/heads/master
| 2021-01-15T19:28:30.400922 | 2013-11-24T21:13:24 | 2013-11-24T21:13:24 | 14,132,013 | 3 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 27,616 |
ss
|
nested-foof-loop.ss
|
;;; -*- Mode: Scheme -*-
;;;; Nested Loops with foof-loop, Version 10 (BETA)
;;; Copyright (c) 2008, Taylor R. Campbell
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; * Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in
;;; the documentation and/or other materials provided with the
;;; distribution.
;;;
;;; * Neither the names of the authors nor the names of contributors
;;; may be used to endorse or promote products derived from this
;;; software without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(module nested-foof-loop
(collect-and
(collect-average receive)
collect-count
collect-display
collect-extremum
collect-extremum*
collect-extremum-by
collect-first
collect-into-string!
collect-into-vector!
collect-last
collect-list
collect-list!
collect-list-into!
collect-list-reverse
collect-maximum
collect-maximum*
collect-maximum-by
collect-minimum
collect-minimum*
collect-minimum-by
collect-or
collect-product
collect-stream
collect-string
collect-string-of-length
collect-sum
collect-vector
collect-vector-of-length
iterate
iterate!
(iterate* values*)
iterate-values
lazy-recur
lazy-recur*
(nested-lazy-loop %nested-loop)
(nested-loop loop)
recur
recur*
recur-values)
(import (alias scheme (values* values)))
(import syn-param)
(import srfi-8)
(import foof-loop)
(define-syntax nested-loop
(syntax-rules ()
((NESTED-LOOP continuation ((state initial) ...) combiner
clause0 clause1+ ...)
(%NESTED-LOOP LOOP continuation ((state initial) ...) combiner
clause0 clause1+ ...))))
(define-syntax nested-lazy-loop
(syntax-rules ()
((NESTED-LOOP continuation ((state initial) ...) combiner
clause0 clause1+ ...)
(%NESTED-LOOP LAZY-LOOP continuation ((state initial) ...) combiner
clause0 clause1+ ...))))
(define-syntax %nested-loop
(syntax-rules (PARALLEL NESTED DO LET LET-VALUES IF NOT AND OR)
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
expression)
(LET ((state initial) ...)
(combiner (LAMBDA () expression) continuation)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(PARALLEL (iterator ...) ...)
clause0 clause1+ ...)
(looper CONTINUE ((WITH state initial)
...
(iterator ...)
...)
=> (continuation state ...)
(%NESTED-LOOP looper (LAMBDA (state ...) (CONTINUE state ...))
((state state) ...)
combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(NESTED clause ...)
clause0 clause1+ ...)
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause ... clause0 clause1+ ...))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(DO command ...)
clause0 clause1+ ...)
(BEGIN command ...
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(LET ((variable value) ...))
clause0 clause1+ ...)
(LET ((variable value) ...)
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(LET variable value)
clause0 clause1+ ...)
(LET ((variable value))
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(LET-VALUES ((bvl expression) ...))
clause0 clause1+ ...)
(LET-VALUES ((bvl expression) ...)
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(LET-VALUES bvl expression)
clause0 clause1+ ...)
(LET-VALUES ((bvl expression))
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(IF condition)
clause0 clause1+ ...)
(IF condition
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
clause0 clause1+ ...)
(continuation initial ...)))
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
((iterator ...) ...)
clause0 clause1+ ...)
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
(PARALLEL (iterator ...) ...)
clause0 clause1+ ...))
;** This clause must come last! It would shadow the others.
((%NESTED-LOOP looper continuation ((state initial) ...) combiner
(iterator ...)
clause0 clause1+ ...)
(%NESTED-LOOP looper continuation ((state initial) ...) combiner
(PARALLEL (iterator ...))
clause0 clause1+ ...))))
;;;; Iteration
(define-syntax iterate*
(syntax-rules (=>)
((ITERATE* ((state initial) ...) => result stepper clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA (state ...) result)
((state initial) ...) stepper clause0 clause1+ ...))
((ITERATE* ((state initial) ...) stepper clause0 clause1+ ...)
(NESTED-LOOP VALUES* ((state initial) ...) stepper
clause0 clause1+ ...))))
(define-syntax iterate
(syntax-rules (=>)
((ITERATE ((state initial) ...) => result stepper clause0 clause1+ ...)
(ITERATE* ((state initial) ...) => result
(LAMBDA (BODY CONTINUATION)
(RECEIVE (state ...) (stepper (BODY) state ...)
(CONTINUATION state ...)))
clause0 clause1+ ...))
((ITERATE ((state initial) ...) stepper clause0 clause1+ ...)
(ITERATE* ((state initial) ...)
(LAMBDA (BODY CONTINUATION)
(RECEIVE (state ...) (stepper (BODY) state ...)
(CONTINUATION state ...)))
clause0 clause1+ ...))))
(define-syntax iterate!
(syntax-rules ()
((ITERATE! clause0 clause1+ ...)
(ITERATE* () ;No state
(LAMBDA (BODY CONTINUATION) (BODY) (CONTINUATION))
clause0 clause1+ ...))))
(define-syntax iterate-values
(syntax-rules (=>)
((ITERATE-VALUES ((state initial) ...) => result
clause0 clause1+ ...)
(ITERATE* ((state initial) ...) => result CALL-WITH-VALUES
clause0 clause1+ ...))
((ITERATE-VALUES updater ((state initial) ...) => result
clause0 clause1+ ...)
;++ This should be visible only in the final expression. However,
;++ that requires tail patterns, which are non-standard.
(WITH-EXTENDED-PARAMETER-OPERATORS
((updater (VALUES* (state . state) ...)))
(ITERATE-VALUES ((state initial) ...) => result clause0 clause1+ ...)))
((ITERATE-VALUES ((state initial) ...) clause0 clause1+ ...)
(ITERATE* ((state initial) ...) CALL-WITH-VALUES
clause0 clause1+ ...))
((ITERATE-VALUES updater ((state initial) ...) clause0 clause1+ ...)
(WITH-EXTENDED-PARAMETER-OPERATORS
((updater (VALUES* (state . state) ...)))
(ITERATE* ((state initial) ...) CALL-WITH-VALUES
clause0 clause1+ ...)))))
;++ Hack for MIT Scheme, whose multiple return values are broken.
;; (define-syntax values*
;; (syntax-rules ()
;; ((VALUES* single) single)
;; ((VALUES* multiple ...) (VALUES multiple ...))))
;;;; Recursion
(define-syntax recur*
(syntax-rules ()
((RECUR* base-case combiner clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA () base-case)
() ;No state
combiner
clause0 clause1+ ...))))
(define-syntax lazy-recur*
(syntax-rules ()
((LAZY-RECUR* base-case combiner clause0 clause1+ ...)
(NESTED-LAZY-LOOP (LAMBDA () base-case)
() ;No state
combiner
clause0 clause1+ ...))))
(define-syntax recur
(syntax-rules ()
((RECUR base-case combiner clause0 clause1+ ...)
(RECUR* base-case
(LAMBDA (BODY CONTINUATION)
(combiner (BODY) (CONTINUATION)))
clause0 clause1+ ...))))
(define-syntax lazy-recur
(syntax-rules ()
((LAZY-RECUR base-case combiner clause0 clause1+ ...)
(LAZY-RECUR* base-case
(LAMBDA (BODY CONTINUATION)
(combiner (BODY) (CONTINUATION)))
clause0 clause1+ ...))))
(define-syntax recur-values
(syntax-rules (=>)
((RECUR-VALUES base-case => result clause0 clause1+ ...)
(CALL-WITH-VALUES (LAMBDA ()
(RECUR-VALUES base-case clause0 clause1+ ...))
result))
((RECUR-VALUES base-case clause0 clause1+ ...)
(RECUR* base-case
(LAMBDA (RECEIVER-BODY RECURSION)
(CALL-WITH-VALUES RECURSION (RECEIVER-BODY)))
clause0 clause1+ ...))))
;;;; Collecting Lists & Streams
(define-syntax collect-list-reverse
(syntax-rules (INITIAL)
((COLLECT-LIST-REVERSE (INITIAL tail-expression) clause0 clause1+ ...)
(ITERATE ((TAIL tail-expression)) CONS clause0 clause1+ ...))
((COLLECT-LIST-REVERSE clause0 clause1+ ...)
(COLLECT-LIST-REVERSE (INITIAL '()) clause0 clause1+ ...))))
;;; The first definition of COLLECT-LIST is probably the one that you
;;; want. On the other hand, what follows in comments is elegant, and
;;; shows the flexibility of the mchanism, especially when compared
;;; with the definition of COLLECT-STREAM.
(define-syntax collect-list
(syntax-rules (INITIAL)
((COLLECT-LIST (INITIAL tail-expression) clause0 clause1+ ...)
(APPEND-REVERSE (COLLECT-LIST-REVERSE clause0 clause1+ ...)
tail-expression))
((COLLECT-LIST clause0 clause1+ ...)
(REVERSE (COLLECT-LIST-REVERSE clause0 clause1+ ...)))))
; (define-syntax collect-list
; (syntax-rules (INITIAL)
;
; ((COLLECT-LIST (INITIAL tail-expression) clause0 clause1+ ...)
; (RECUR tail-expression CONS clause0 clause1+ ...))
;
; ((COLLECT-LIST clause0 clause1+ ...)
; (COLLECT-LIST (INITIAL '()) clause0 clause1+ ...))))
(define-syntax collect-stream
(syntax-rules (INITIAL)
((COLLECT-STREAM (INITIAL tail-expression) clause0 clause1+ ...)
(LAZY-RECUR tail-expression STREAM-CONS clause0 clause1+ ...))
((COLLECT-STREAM clause0 clause1+ ...)
(COLLECT-STREAM (INITIAL STREAM-NIL) clause0 clause1+ ...))))
(define-syntax collect-list!
(syntax-rules (INITIAL)
((COLLECT-LIST! (INITIAL tail-expression) clause0 clause1+ ...)
(LET ((PAIR (CONS #F tail-expression)))
(COLLECT-LIST-INTO! PAIR clause0 clause1+ ...)
(CDR PAIR)))
((COLLECT-LIST! clause0 clause1+ ...)
(COLLECT-LIST! (INITIAL '()) clause0 clause1+ ...))))
(define-syntax collect-list-into!
(syntax-rules ()
((COLLECT-LIST-INTO! pair-expression clause0 clause1+ ...)
(ITERATE* ((PAIR pair-expression))
(LAMBDA (BODY CONTINUATION)
(LET ((TAIL (CONS (BODY) (CDR PAIR))))
(SET-CDR! PAIR TAIL)
(CONTINUATION TAIL)))
clause0 clause1+ ...))))
;;;; Collecting Vectors and Strings
(define-syntax collect-vector
(syntax-rules ()
((COLLECT-VECTOR clause0 clause1+ ...)
(LIST->VECTOR (COLLECT-LIST clause0 clause1+ ...)))))
(define-syntax collect-string
(syntax-rules ()
((COLLECT-STRING clause0 clause1+ ...)
(LIST->STRING (COLLECT-LIST clause0 clause1+ ...)))))
;;; The following definition of COLLECT-DISPLAY can collect any object,
;;; whose printed representation is computed using DISPLAY; it relies
;;; on SRFI 6 (Basic String Ports) to accomplish this.
(define-syntax collect-display
(syntax-rules ()
((COLLECT-DISPLAY clause0 clause1+ ...)
(LET ((OUTPUT-PORT (OPEN-OUTPUT-STRING)))
(ITERATE* () ;No state
(LAMBDA (BODY CONTINUATION)
(DISPLAY (BODY) OUTPUT-PORT)
(CONTINUATION))
clause0 clause1+ ...)
(GET-OUTPUT-STRING OUTPUT-PORT)))))
;;;;; Expanding Vector and String Collection
;;; These are slower than the definitions with lists. Go figure.
; (define-syntax collect-vector
; (syntax-rules ()
; ((COLLECT-VECTOR clause0 clause1+ ...)
; (%COLLECT-VECTOR
; (MAKE-VECTOR VECTOR-LENGTH VECTOR-SET! IN-VECTOR)
; DATUM
; () ;No check for the data.
; clause0 clause1+ ...))))
;
; (define-syntax collect-string
; (syntax-rules ()
; ((COLLECT-STRING clause0 clause1+ ...)
; (%COLLECT-VECTOR
; (MAKE-STRING STRING-LENGTH STRING-SET! IN-STRING)
; DATUM
; ((IF (NOT (CHAR? DATUM))
; (ERROR "Non-character in COLLECT-STRING:" DATUM)))
; clause0 clause1+ ...))))
;
; (define-syntax %collect-vector
; (syntax-rules ()
; ((%COLLECT-VECTOR
; (make-vector vector-length vector-set! in-vector)
; datum (check ...)
; clause0 clause1+ ...)
; (RECEIVE (LENGTH CHUNK-INDEX CHUNK CHUNKS)
; (ITERATE ((LENGTH 0)
; (CHUNK-INDEX 0)
; (CHUNK (make-vector #x10))
; (CHUNKS '()))
; (LAMBDA (datum LENGTH CHUNK-INDEX CHUNK CHUNKS)
; check ...
; (LET ((CHUNK-LENGTH (vector-length CHUNK)))
; (IF (< CHUNK-INDEX CHUNK-LENGTH)
; (BEGIN
; (vector-set! CHUNK CHUNK-INDEX datum)
; (VALUES LENGTH
; (+ CHUNK-INDEX 1)
; CHUNK
; CHUNKS))
; (LET ((CHUNK*
; (make-vector
; (IF (>= CHUNK-LENGTH #x1000)
; #x1000
; (* CHUNK-LENGTH 2)))))
; (vector-set! CHUNK* 0 datum)
; (VALUES (+ LENGTH CHUNK-LENGTH)
; 1 ;We filled in the first slot,
; CHUNK* ; so start at index 1.
; (CONS CHUNK CHUNKS))))))
; clause0 clause1+ ...)
; (LET* ((TOTAL-LENGTH (+ LENGTH CHUNK-INDEX))
; (RESULT (make-vector TOTAL-LENGTH)))
; (LOOP ((FOR ELEMENT OFFSET (in-vector CHUNK 0 CHUNK-INDEX)))
; (vector-set! RESULT (+ LENGTH OFFSET) ELEMENT))
; (LOOP ((FOR CHUNK (IN-LIST CHUNKS))
; (WITH BASE LENGTH BASE*)
; (LET BASE* (- BASE (vector-length CHUNK))))
; (LOOP ((FOR ELEMENT OFFSET (in-vector CHUNK)))
; (vector-set! RESULT (+ BASE* OFFSET) ELEMENT)))
; RESULT)))))
;;;;; Non-reentrant Vector and String Collection
;;; For the following definitions, we defer the responsibility of
;;; bounds checking and error signalling to VECTOR-SET! and
;;; STRING-SET!. This may not be a good idea.
(define-syntax collect-into-vector!
(syntax-rules (FROM)
((COLLECT-INTO-VECTOR! vector-expression (FROM start-expression)
clause0 clause1+ ...)
(LET ((VECTOR vector-expression)
(START start-expression))
(ITERATE* ((INDEX start))
(LAMBDA (BODY CONTINUATION)
(VECTOR-SET! VECTOR INDEX (BODY))
(CONTINUATION (+ INDEX 1)))
clause0 clause1+ ...)))
((COLLECT-INTO-VECTOR! vector-expression clause0 clause1+ ...)
(COLLECT-INTO-VECTOR! vector-expression (FROM 0) clause0 clause1+ ...))))
(define-syntax collect-into-string!
(syntax-rules (FROM)
((COLLECT-INTO-STRING! string-expression (FROM start-expression)
clause0 clause1+ ...)
(LET ((STRING string-expression)
(START start-expression))
(ITERATE* ((INDEX start))
(LAMBDA (BODY CONTINUATION)
(STRING-SET! STRING INDEX (BODY))
(CONTINUATION (+ INDEX 1)))
clause0 clause1+ ...)))
((COLLECT-INTO-STRING! string-expression clause0 clause1+ ...)
(COLLECT-INTO-STRING! string-expression (FROM 0) clause0 clause1+ ...))))
;;; These should probably have bang suffixes to emphasize that they are
;;; non-reentrant.
(define-syntax collect-vector-of-length
(syntax-rules ()
((COLLECT-VECTOR-OF-LENGTH length clause0 clause1+ ...)
(LET ((VECTOR (MAKE-VECTOR length)))
(COLLECT-INTO-VECTOR! VECTOR clause0 clause1+ ...)
VECTOR))))
(define-syntax collect-string-of-length
(syntax-rules ()
((COLLECT-STRING-OF-LENGTH length clause0 clause1+ ...)
(LET ((STRING (MAKE-STRING length)))
(COLLECT-INTO-STRING! STRING clause0 clause1+ ...)
STRING))))
;;;; Numerical Collection
(define-syntax collect-sum
(syntax-rules (INITIAL)
((COLLECT-SUM (INITIAL value-expression) clause0 clause1+ ...)
(ITERATE ((SUM value-expression)) + clause0 clause1+ ...))
((COLLECT-SUM clause0 clause1+ ...)
(COLLECT-SUM (INITIAL 0) clause0 clause1+ ...))))
(define-syntax collect-product
(syntax-rules (INITIAL)
((COLLECT-PRODUCT (INITIAL value-expression) clause0 clause1+ ...)
(ITERATE ((PRODUCT value-expression)) * clause0 clause1+ ...))
((COLLECT-PRODUCT clause0 clause1+ ...)
(COLLECT-PRODUCT (INITIAL 1) clause0 clause1+ ...))))
(define-syntax collect-count
(syntax-rules ()
((COLLECT-COUNT clause0 clause1+ ...)
(COLLECT-SUM clause0 clause1+ ... 1))))
(define-syntax collect-average
(syntax-rules ()
((COLLECT-AVERAGE clause0 clause1+ ...)
(RECEIVE (SUM COUNT)
(ITERATE* ((SUM 0) (COUNT 0))
(LAMBDA (BODY CONTINUATION)
(CONTINUATION (+ SUM (BODY)) (+ COUNT 1)))
clause0 clause1+ ...)
(/ SUM COUNT)))))
;;;; Collecting Extrema
(define-syntax collect-extremum
(syntax-rules (INITIAL)
((COLLECT-EXTREMUM comparator-expression (INITIAL initial-expression)
clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression))
(ITERATE ((EXTREMUM initial-expression))
(LAMBDA (DATUM EXTREMUM)
(IF (COMPARATOR DATUM EXTREMUM) DATUM EXTREMUM))
clause0 clause1+ ...)))
((COLLECT-EXTREMUM comparator-expression clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression))
(ITERATE ((EXTREMUM #F))
(LAMBDA (DATUM EXTREMUM)
(IF (AND DATUM EXTREMUM)
(IF (COMPARATOR DATUM EXTREMUM) DATUM EXTREMUM)
(OR DATUM EXTREMUM)))
clause0 clause1+ ...)))))
(define-syntax collect-minimum
(syntax-rules (INITIAL)
((COLLECT-MINIMUM (INITIAL initial-expression) clause0 clause1+ ...)
(ITERATE ((MINIMUM initial-expression)) MIN clause0 clause1+ ...))
((COLLECT-MINIMUM clause0 clause1+ ...)
(ITERATE ((MINIMUM #F))
(LAMBDA (DATUM MINIMUM)
(IF (AND DATUM MINIMUM)
(MIN DATUM MINIMUM)
(OR DATUM MINIMUM)))
clause0 clause1+ ...))))
(define-syntax collect-maximum
(syntax-rules (INITIAL)
((COLLECT-MAXIMUM (INITIAL initial-expression) clause0 clause1+ ...)
(ITERATE ((MAXIMUM initial-expression)) MAX clause0 clause1+ ...))
((COLLECT-MAXIMUM clause0 clause1+ ...)
(ITERATE ((MAXIMUM #F))
(LAMBDA (DATUM MAXIMUM)
(IF (AND DATUM MAXIMUM)
(MAX DATUM MAXIMUM)
(OR DATUM MAXIMUM)))
clause0 clause1+ ...))))
;;;;; Generalization by Multiple Values
(define-syntax collect-extremum*
(syntax-rules (INITIAL)
((COLLECT-EXTREMUM* comparator-expression
(INITIAL key-expression element-expression)
clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression)
(INITIAL-KEY key-expression)
(INITIAL-ELEMENT element-expression))
(ITERATE* ((EXTREME-KEY INITIAL-KEY)
(EXTREME-ELEMENT INITIAL-ELEMENT))
(LAMBDA (BODY CONTINUATION)
(RECEIVE (KEY ELEMENT) (BODY)
(IF (COMPARATOR KEY EXTREME-KEY)
(CONTINUATION KEY ELEMENT)
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))))
clause0 clause1+ ...)))
((COLLECT-EXTREMUM* comparator-expression clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression))
(ITERATE* ((EXTREME-KEY #F)
(EXTREME-ELEMENT #F))
(LAMBDA (BODY CONTINUATION)
(RECEIVE (KEY ELEMENT) (BODY)
(IF KEY
(IF EXTREME-KEY
(IF (COMPARATOR KEY EXTREME-KEY)
(CONTINUATION KEY ELEMENT)
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))
(CONTINUATION KEY ELEMENT))
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))))
clause0 clause1+ ...)))))
(define-syntax collect-minimum*
(syntax-rules (INITIAL)
((COLLECT-MINIMUM* (INITIAL key-expression element-expression)
clause0 clause1+ ...)
(COLLECT-EXTREMUM* < (INITIAL key-expression element-expression)
clause0 clause1+ ...))
((COLLECT-MINIMUM* clause0 clause1+ ...)
(COLLECT-EXTREMUM* < clause0 clause1+ ...))))
(define-syntax collect-maximum*
(syntax-rules (INITIAL)
((COLLECT-MAXIMUM* (INITIAL key-expression element-expression)
clause0 clause1+ ...)
(COLLECT-EXTREMUM* < (INITIAL key-expression element-expression)
clause0 clause1+ ...))
((COLLECT-MAXIMUM* clause0 clause1+ ...)
(COLLECT-EXTREMUM* < clause0 clause1+ ...))))
;;;;; Generalization by Selectors
(define-syntax collect-extremum-by
(syntax-rules (INITIAL)
((COLLECT-EXTREMUM-BY comparator-expression selector-expression
(INITIAL initial-expression)
clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression)
(SELECTOR selector-expression)
(INITIAL-ELEMENT initial-expression))
(ITERATE* ((EXTREME-KEY (SELECTOR INITIAL-ELEMENT))
(EXTREME-ELEMENT INITIAL-ELEMENT))
=> EXTREME-ELEMENT
(LAMBDA (BODY CONTINUATION)
(LET* ((ELEMENT (BODY))
(KEY (SELECTOR ELEMENT)))
(IF (COMPARATOR KEY EXTREME-KEY)
(CONTINUATION KEY ELEMENT)
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))))
clause0 clause1+ ...)))
((COLLECT-EXTREMUM-BY comparator-expression selector-expression
clause0 clause1+ ...)
(LET ((COMPARATOR comparator-expression)
(SELECTOR selector-expression))
(ITERATE* ((EXTREME-KEY #F) (EXTREME-ELEMENT #F))
=> EXTREME-ELEMENT
(LAMBDA (BODY CONTINUATION)
(LET* ((ELEMENT (BODY))
(KEY (SELECTOR ELEMENT)))
(IF KEY
(IF EXTREME-KEY
(IF (COMPARATOR KEY EXTREME-KEY)
(CONTINUATION KEY ELEMENT)
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))
(CONTINUATION KEY ELEMENT))
(CONTINUATION EXTREME-KEY EXTREME-ELEMENT))))
clause0 clause1+ ...)))))
(define-syntax collect-minimum-by
(syntax-rules (INITIAL)
((COLLECT-MINIMUM-BY selector-expression (INITIAL initial-expression)
clause0 clause1+ ...)
(COLLECT-EXTREMUM-BY < selector-expression (INITIAL initial-expression)
clause0 clause1+ ...))
((COLLECT-MINIMUM-BY selector-expression clause0 clause1+ ...)
(COLLECT-EXTREMUM-BY < selector-expression clause0 clause1+ ...))))
(define-syntax collect-maximum-by
(syntax-rules (INITIAL)
((COLLECT-MAXIMUM-BY selector-expression (INITIAL initial-expression)
clause0 clause1+ ...)
(COLLECT-EXTREMUM-BY > selector-expression (INITIAL initial-expression)
clause0 clause1+ ...))
((COLLECT-MAXIMUM-BY selector-expression clause0 clause1+ ...)
(COLLECT-EXTREMUM-BY > selector-expression clause0 clause1+ ...))))
;;;; Miscellaneous
;;; COLLECT-FIRST and COLLECT-OR work nicely. COLLECT-LAST and
;;; COLLECT-AND have the unfortunate property that the final expression
;;; is not evaluated in a tail position, which is very hard to arrange
;;; in the general case. For example, compare these two definitions of
;;; (a reduced version of) EVERY from SRFI 1:
;;;
;;; (define (every predicate list)
;;; (and (pair? list)
;;; (let loop ((list list))
;;; (let ((tail (cdr list)))
;;; (if (pair? tail)
;;; (and (predicate (car list))
;;; (loop tail))
;;; (predicate (car list)))))))
;;;
;;; (define (every predicate list)
;;; (collect-and (for element (in-list list))
;;; (predicate element)))
;;;
;;; The first definition duplicates the call to PREDICATE so that the
;;; last is in a tail position. COLLECT-AND cannot do this.
(define-syntax collect-first
(syntax-rules (DEFAULT)
((COLLECT-FIRST (DEFAULT default-expression) clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA () default-expression)
() ;No state
(LAMBDA (BODY CONTINUATION)
CONTINUATION ;ignore
(BODY))
clause0 clause1+ ...))
((COLLECT-FIRST clause0 clause1+ ...)
(COLLECT-FIRST (DEFAULT (ERROR "Nothing generated in COLLECT-FIRST."))
clause0 clause1+ ...))))
(define-syntax collect-last
(syntax-rules (DEFAULT)
((COLLECT-LAST (DEFAULT default-expression) clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA (RESULT) RESULT)
((RESULT default-expression))
(LAMBDA (BODY CONTINUATION) (CONTINUATION (BODY)))
clause0 clause1+ ...))))
(define-syntax collect-or
(syntax-rules ()
((COLLECT-OR clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA () #F)
() ;No state
(LAMBDA (BODY CONTINUATION) (OR (BODY) (CONTINUATION)))
clause0 clause1+ ...))))
(define-syntax collect-and
(syntax-rules ()
((COLLECT-AND clause0 clause1+ ...)
(NESTED-LOOP (LAMBDA (RESULT) RESULT)
((RESULT #F))
(LAMBDA (BODY CONTINUATION)
(LET ((RESULT (BODY))) (AND RESULT (CONTINUATION RESULT))))
clause0 clause1+ ...))))
)
| true |
4f86b207ab810b5290f319eac436755ce6b57ba6
|
fae4190f90ada065bc9e5fe64aab0549d4d4638a
|
/pre-effect/private/type-equal.ss
|
cab87ecfe6c3fbd38d3f64b7bf440af08d0659f7
|
[] |
no_license
|
ilya-klyuchnikov/old-typed-racket
|
f161481661a2ed5cfc60e268f5fcede728d22488
|
fa7c1807231f447ff37497e89b25dcd7a9592f64
|
refs/heads/master
| 2021-12-08T04:19:59.894779 | 2008-04-13T10:54:34 | 2008-04-13T10:54:34 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 152 |
ss
|
type-equal.ss
|
(module type-equal mzscheme
(require (all-except (lib "unit.ss") rename) "big-unit.ss" "signatures.ss")
(provide-signature-elements type-equal^)
)
| false |
d6226d9a923b50d2e6b84c2810f82a6029bf7bd0
|
40395de4446cbdbf1ffd0d67f9076c1f61d572ad
|
/tests/04-macro-let.scm
|
83f079bfcac53c648c73adad998376d7b460c660
|
[] |
no_license
|
justinethier/nugget
|
959757d66f0a8597ab9a25d027eb17603e3e1823
|
0c4e3e9944684ea83191671d58b5c8c342f64343
|
refs/heads/master
| 2020-12-22T06:36:53.844584 | 2016-07-14T03:30:09 | 2016-07-14T03:30:09 | 3,466,831 | 16 | 4 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 59 |
scm
|
04-macro-let.scm
|
(begin 48 (let ((x 90)) (+ x x))) ; Another closure issue?
| false |
4464e58142c7a8bf8739e2983e7b6d7aa0ef8a72
|
000dbfe5d1df2f18e29a76ea7e2a9556cff5e866
|
/ext/crypto/tests/testvectors/signature/rsa_signature_4096_sha384_test.scm
|
9cb066341d4f9c3e77d199ee5869f6bb242d8e5e
|
[
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive",
"MIT",
"BSD-2-Clause"
] |
permissive
|
ktakashi/sagittarius-scheme
|
0a6d23a9004e8775792ebe27a395366457daba81
|
285e84f7c48b65d6594ff4fbbe47a1b499c9fec0
|
refs/heads/master
| 2023-09-01T23:45:52.702741 | 2023-08-31T10:36:08 | 2023-08-31T10:36:08 | 41,153,733 | 48 | 7 |
NOASSERTION
| 2022-07-13T18:04:42 | 2015-08-21T12:07:54 |
Scheme
|
UTF-8
|
Scheme
| false | false | 460,087 |
scm
|
rsa_signature_4096_sha384_test.scm
|
(test-signature/testvector
"rsa_signature_4096_sha384_test"
:algorithm
"RSASSA-PKCS1-v1_5"
:digest
"SHA-384"
:public-key
#vu8(48 130 2 34 48 13 6 9 42 134 72 134 247 13 1 1 1 5 0 3 130 2 15 0 48 130 2 10 2 130 2 1 0 227 174 125 229 191 68 222 125 53 126 35 140 141 255 6 60 167 19 71 7 119 171 120 107 73 88 132 231 169 186 29 222 101 222 125 43 91 227 242 183 209 131 12 246 202 142 213 192 93 63 9 74 170 235 29 210 228 178 237 224 134 19 16 154 155 163 76 126 43 248 69 2 37 151 67 116 69 159 22 218 44 20 25 44 99 121 133 254 190 187 239 1 240 56 30 120 208 253 99 183 96 56 245 227 211 93 199 210 36 57 99 54 106 245 215 104 95 27 207 201 157 203 145 233 76 147 1 144 104 53 49 34 237 208 60 195 230 21 225 124 27 241 221 124 67 218 232 111 71 164 2 56 251 89 64 65 206 189 186 37 243 254 149 147 166 195 41 183 247 196 118 234 183 98 93 23 186 123 231 136 105 54 183 51 248 220 230 230 201 55 245 136 218 19 21 193 17 122 189 41 200 56 149 217 89 136 209 127 159 215 98 57 96 216 228 51 215 198 132 21 7 255 47 170 195 110 14 25 164 30 178 204 205 178 162 192 250 233 102 113 154 153 210 3 201 36 52 155 192 238 161 55 78 253 62 35 9 155 45 24 121 34 1 111 208 20 8 117 32 166 115 99 104 115 34 185 13 122 137 13 143 68 100 168 199 148 210 163 242 7 12 205 59 14 187 202 43 66 187 248 235 166 242 192 191 128 8 181 97 110 231 184 22 41 235 255 151 169 58 91 134 25 137 218 161 13 167 200 227 188 123 12 219 9 95 108 225 24 92 248 253 61 202 3 94 179 229 5 203 224 34 216 29 147 148 90 20 72 6 185 254 11 160 127 58 185 199 14 114 181 251 119 172 110 76 126 3 170 45 206 124 94 242 39 171 161 172 212 140 29 147 224 226 111 1 232 241 228 58 169 120 128 209 93 108 146 75 6 13 31 172 226 29 3 167 150 200 99 1 244 167 67 57 228 114 178 249 108 208 117 87 65 203 157 243 83 80 119 56 26 218 132 209 188 8 70 166 196 76 138 141 60 254 27 122 153 19 209 243 215 175 44 94 164 230 124 224 167 237 60 0 88 32 111 209 58 217 204 173 90 130 18 243 236 215 136 54 138 107 97 72 23 140 124 94 168 214 211 133 34 127 44 118 160 71 33 110 94 32 107 30 209 2 3 1 0 1)
:der-encode
#t
:tests
'(#(1
""
#vu8()
#vu8(164 84 57 11 4 191 221 105 196 190 42 209 186 217 110 201 1 99 159 11 182 13 242 104 65 91 74 147 180 205 83 81 15 230 79 57 75 49 158 102 202 134 5 215 213 247 160 93 174 94 255 130 112 96 1 53 3 216 87 169 119 192 158 247 66 82 94 67 183 230 157 56 2 165 130 6 230 150 132 138 135 238 23 178 185 222 104 41 4 67 73 3 101 84 198 89 200 248 134 108 64 31 232 88 105 192 165 234 144 115 156 73 131 161 86 26 132 228 240 188 235 0 1 90 103 31 82 131 244 31 11 184 89 151 116 130 155 106 45 226 79 20 216 51 81 201 110 53 174 20 117 200 180 188 210 207 102 136 146 55 162 6 209 71 176 233 73 242 178 2 142 173 55 156 116 32 48 23 144 74 192 154 85 97 168 236 52 59 226 44 244 108 59 194 168 123 18 207 156 246 232 251 34 222 136 75 221 150 119 98 107 117 122 0 93 55 69 243 135 210 150 52 125 56 82 221 194 196 37 140 245 114 220 64 223 63 246 168 165 249 216 177 180 16 197 71 57 185 174 24 38 17 236 1 128 92 128 180 69 208 88 206 42 252 75 213 141 135 192 63 201 80 15 186 35 123 203 237 176 150 10 26 2 239 239 82 185 124 221 172 99 181 235 4 129 192 192 153 19 117 115 83 56 172 132 192 80 84 21 173 43 248 231 168 25 173 38 148 96 102 139 168 248 200 121 245 33 236 157 199 9 228 6 222 2 63 192 249 18 154 58 148 235 31 58 240 141 51 238 214 39 62 81 102 243 17 16 9 127 85 88 216 217 2 143 245 88 230 39 201 192 219 36 84 177 52 168 42 157 172 202 91 64 50 188 14 39 196 212 28 245 94 157 137 207 81 82 139 180 240 140 110 229 206 101 26 243 119 47 0 138 68 134 60 133 25 51 165 124 172 142 41 168 71 86 201 250 127 128 67 91 59 120 72 111 153 8 81 41 2 213 70 25 100 145 130 57 199 107 103 144 183 128 224 157 47 29 61 177 197 155 39 93 32 187 36 250 79 81 139 37 175 50 84 182 29 52 237 139 68 77 60 167 54 206 255 221 218 247 103 189 201 43 69 67 246 139 37 66 28 184 193 50 143 47 37 62 68 107 228 109 16)
#t
())
#(2
""
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#vu8(144 156 31 19 181 68 147 60 207 59 199 63 245 5 58 138 101 168 240 27 68 125 75 64 241 9 203 222 41 216 102 54 138 174 191 70 193 144 81 9 32 99 153 56 98 179 47 209 102 0 107 221 77 152 135 148 212 233 167 120 33 252 158 104 79 171 19 102 162 217 136 234 202 96 228 250 142 169 71 219 196 184 67 138 159 192 54 105 17 7 211 208 190 82 196 108 97 52 46 248 251 126 8 3 41 33 193 180 85 197 93 226 141 88 199 124 30 174 160 63 19 194 108 76 234 115 209 74 207 168 172 41 7 246 167 117 39 62 118 134 236 244 184 130 184 138 66 203 161 28 209 239 165 185 133 207 90 34 118 84 229 76 220 158 45 40 59 128 210 80 204 229 83 253 166 54 39 147 54 186 19 247 243 101 157 112 181 178 153 90 42 199 182 15 50 156 98 121 13 142 237 28 61 172 204 208 223 70 138 145 231 103 193 144 190 65 160 40 212 239 193 197 237 94 111 58 119 147 15 80 33 127 222 156 233 204 182 107 117 115 25 87 149 152 52 131 159 163 189 193 167 105 250 190 186 176 61 63 14 96 90 18 170 159 204 178 169 66 21 145 167 66 125 130 6 134 35 88 45 229 146 147 89 4 181 154 66 229 155 80 65 156 209 45 113 218 135 24 98 20 154 101 0 236 104 112 217 137 66 51 70 135 149 81 229 6 250 218 124 12 1 179 40 36 74 197 242 226 197 188 191 75 91 9 164 81 42 14 220 144 254 228 212 221 158 184 133 130 191 227 123 73 184 216 24 144 81 179 44 204 188 77 48 2 132 249 229 35 103 74 96 27 26 114 87 34 105 93 94 244 56 183 112 181 117 182 208 149 94 220 118 18 80 188 198 163 14 141 92 114 135 9 50 54 242 35 194 218 141 154 183 214 181 142 93 14 145 103 242 232 197 130 85 237 22 182 55 137 234 22 4 107 208 249 135 177 86 233 137 128 118 212 68 204 122 74 173 199 102 153 162 227 164 66 214 60 164 195 249 45 169 243 178 196 174 19 237 249 212 226 138 210 6 237 12 189 45 242 164 105 32 226 152 171 209 144 72 119 183 92 26 159 248 12 91 240 91 197 209 171 148 211 121 208 100 250 216 148 145 140 227 38)
#t
())
#(3
""
#vu8(84 101 115 116)
#vu8(101 149 97 33 168 24 184 66 216 97 208 219 203 222 242 42 160 92 126 148 206 93 116 131 8 102 62 20 40 129 254 173 184 93 196 66 29 157 1 131 59 139 76 39 19 132 44 119 148 156 238 139 133 50 134 16 124 101 93 231 119 138 90 204 161 26 251 241 217 218 212 41 235 106 40 28 30 138 225 207 211 124 223 83 15 212 242 183 101 195 82 188 234 38 206 68 226 22 92 54 85 51 24 216 155 30 6 255 216 162 16 203 152 140 191 201 22 169 64 31 189 170 86 161 162 164 203 102 239 0 163 23 97 130 211 61 236 95 54 37 183 96 195 124 130 207 97 140 210 135 80 121 163 96 21 175 33 208 96 223 254 181 201 225 244 37 93 127 234 100 56 109 141 134 12 104 104 205 121 239 109 122 135 146 119 83 167 139 219 99 196 132 83 6 222 29 115 197 215 220 203 182 204 169 182 90 239 25 167 185 229 61 156 2 164 162 189 105 16 224 118 149 159 159 64 195 14 170 10 110 247 131 192 183 63 5 86 110 68 146 225 107 131 39 41 224 63 201 57 229 75 240 51 109 55 106 59 76 218 83 75 238 68 109 173 63 229 29 32 187 138 19 81 3 231 225 34 32 72 75 190 2 233 156 88 3 40 42 185 13 17 6 62 82 67 41 127 128 211 242 74 176 143 232 242 251 98 112 43 5 67 240 32 57 114 211 82 135 186 100 250 203 198 53 203 67 138 136 140 131 199 2 138 50 85 85 240 117 33 195 9 91 196 227 139 208 246 14 185 8 40 49 151 119 254 162 39 110 11 199 111 44 19 235 249 47 128 42 8 132 66 9 204 221 210 170 193 242 112 14 138 81 7 232 100 38 230 171 118 40 143 160 29 225 139 138 99 85 31 190 135 5 130 77 22 229 25 12 85 156 123 190 138 23 3 30 125 53 42 104 27 4 24 203 54 66 54 50 236 72 168 211 134 17 54 178 80 173 47 199 35 136 231 113 180 24 73 137 60 219 255 224 74 172 64 55 32 153 68 255 49 116 248 111 122 136 65 75 22 102 114 124 150 11 30 84 162 205 184 46 57 207 159 38 97 244 173 110 34 243 48 179 80 234 231 245 136 166 35 82 70 23 177 132 100 134 254 159 4 171 191 94)
#t
())
#(4
""
#vu8(49 50 51 52 48 48)
#vu8(59 53 160 66 164 121 29 193 172 21 97 173 16 56 117 11 185 165 117 167 255 114 219 46 230 11 160 39 248 153 75 203 171 228 31 237 54 65 123 209 57 162 134 237 10 166 195 239 40 104 167 37 20 66 208 96 193 204 103 212 71 12 58 183 195 7 172 176 192 100 18 24 164 91 156 221 224 85 70 101 56 80 194 22 138 89 241 120 140 213 93 172 212 10 254 56 235 148 31 240 143 250 139 190 96 159 42 167 149 199 60 3 104 244 130 213 61 105 25 128 137 27 164 59 105 245 121 28 46 111 112 225 122 153 106 41 158 96 206 28 157 68 235 185 242 158 112 14 154 226 22 223 116 145 73 246 194 34 209 225 115 57 83 85 58 121 39 69 195 130 212 79 82 255 64 78 213 238 4 196 26 200 172 201 124 37 15 154 94 60 198 215 9 2 213 30 138 192 0 208 94 54 39 157 131 73 29 254 106 64 242 34 188 29 252 250 127 165 224 25 124 244 117 40 247 119 25 224 7 182 92 163 157 174 23 189 15 50 59 0 238 99 182 100 1 226 236 95 137 23 239 96 10 65 195 166 21 113 164 217 34 192 176 173 10 41 14 224 84 173 21 230 63 26 12 175 183 73 248 12 174 108 190 176 107 230 46 22 8 181 2 24 45 36 123 198 163 122 190 95 215 80 234 216 183 33 106 53 231 75 150 144 5 48 155 20 190 54 163 28 94 108 34 102 112 29 90 253 181 202 35 20 226 243 42 225 115 135 216 40 74 210 199 34 95 166 62 212 126 114 69 166 91 116 245 58 91 210 38 84 179 135 142 208 155 30 94 7 11 194 14 239 172 108 149 176 6 184 243 230 19 177 159 81 140 72 238 103 129 161 43 208 138 211 107 163 132 208 61 62 163 196 224 177 250 204 57 116 31 158 199 61 3 53 210 238 115 83 85 149 94 209 44 248 185 153 209 85 211 137 177 163 202 235 223 187 163 44 136 62 247 208 225 18 216 110 97 73 163 50 139 99 185 56 92 104 254 138 123 103 158 132 54 174 247 70 96 103 168 232 187 73 227 22 117 114 155 63 68 142 125 211 192 72 151 61 42 95 143 113 115 196 66 143 57 130 169 147 97 250 105 29 21 136 227 156 212 72 92 69 1 88)
#t
())
#(5
""
#vu8(77 101 115 115 97 103 101)
#vu8(9 216 81 44 70 103 153 70 35 83 10 35 23 187 218 115 142 184 145 123 200 12 132 182 71 147 53 20 99 218 23 27 204 200 139 149 4 154 87 204 217 23 164 104 125 163 190 99 219 33 176 173 9 114 237 158 209 130 244 236 200 224 102 71 103 83 64 25 42 87 230 89 30 172 191 21 210 245 251 220 171 86 139 22 237 134 230 104 20 77 158 103 110 85 236 77 241 220 230 31 103 45 233 245 61 23 67 183 41 147 165 210 31 254 183 171 88 224 248 62 41 124 204 191 37 237 104 199 13 216 68 28 17 154 251 108 7 251 29 131 237 217 188 26 195 64 70 115 60 139 130 125 0 44 59 96 114 215 74 108 44 247 241 217 104 233 247 176 135 61 232 238 90 223 144 45 198 143 188 147 23 31 118 60 66 89 100 234 110 58 246 105 31 26 48 63 247 131 122 219 7 160 159 114 141 227 55 127 255 116 173 179 76 149 157 54 61 182 80 250 92 48 53 254 191 232 198 42 12 222 61 0 106 157 52 213 28 91 44 74 29 212 242 66 60 83 44 107 95 221 240 62 10 5 253 248 216 87 249 135 135 214 245 95 12 225 208 202 149 163 113 119 101 112 53 238 72 189 79 57 247 213 32 204 196 142 233 153 119 120 104 180 195 135 110 34 66 245 155 114 87 152 188 162 138 230 108 38 124 80 124 214 95 222 97 44 31 220 147 98 153 78 227 17 52 213 86 26 215 195 245 35 133 143 67 97 28 36 156 202 60 19 77 0 237 150 106 130 184 0 218 17 173 210 19 115 27 88 202 242 50 251 32 148 233 221 66 206 175 252 112 2 241 89 46 121 184 94 182 227 158 213 222 132 132 245 80 158 15 84 22 100 38 9 94 133 34 248 131 99 253 13 215 191 100 65 64 17 167 16 199 131 73 88 192 170 48 129 137 129 156 212 72 133 136 184 71 41 218 254 22 62 121 133 107 145 62 245 90 254 213 94 131 238 91 129 37 121 184 124 219 128 213 188 159 250 2 236 50 160 217 123 10 86 191 174 173 88 164 56 206 229 61 64 221 25 127 162 238 239 74 255 152 235 85 144 22 62 104 181 243 222 68 57 9 118 144 128 200 166 191 135 227 128 139 242 101 164 26 59 121 248)
#t
())
#(6
""
#vu8(97)
#vu8(121 143 89 126 154 212 186 139 61 0 169 82 127 78 120 90 245 197 89 148 226 149 48 70 161 185 6 41 69 232 223 163 94 237 177 227 26 243 218 241 149 93 123 10 254 116 251 197 55 57 177 170 2 250 45 186 98 156 49 178 17 205 81 62 34 72 237 132 125 213 121 64 106 182 3 211 54 157 227 187 7 20 58 88 23 52 253 139 28 160 53 140 79 218 99 144 69 190 31 25 43 35 62 251 136 72 187 44 84 78 78 24 142 12 124 227 17 187 72 65 7 125 21 5 28 111 107 49 153 141 221 138 123 211 13 117 183 179 200 36 53 139 204 179 95 143 250 140 15 197 172 55 237 113 205 212 142 211 192 38 154 99 131 23 117 107 220 146 135 4 59 225 180 243 198 239 100 35 241 208 211 136 87 193 149 231 190 129 195 119 134 72 171 136 148 116 16 159 243 199 190 15 236 121 13 63 95 80 185 102 227 223 64 197 102 245 114 248 242 82 208 158 151 212 201 4 66 186 223 130 12 125 183 77 111 187 0 75 215 235 83 192 177 168 113 187 159 72 8 33 187 180 139 54 60 133 201 134 107 248 168 109 233 198 115 42 49 54 242 200 14 136 162 149 64 169 3 107 114 251 143 76 137 142 123 72 124 65 208 246 147 201 19 9 187 59 192 111 30 59 47 169 145 140 49 186 42 75 130 163 122 146 119 132 167 199 210 170 220 51 1 82 76 226 112 135 116 195 226 24 156 161 136 179 216 90 51 52 141 40 237 111 8 10 6 69 43 248 49 109 72 62 106 94 40 184 49 121 127 133 168 202 92 169 34 188 217 75 144 69 245 136 234 158 21 242 162 13 210 104 23 238 184 11 52 33 197 222 114 219 152 132 61 199 25 207 177 175 241 249 39 238 29 241 187 113 135 50 21 155 236 112 213 182 208 249 138 63 213 212 44 49 236 244 18 76 177 117 159 24 56 56 214 118 236 162 202 219 77 87 242 214 165 44 208 17 95 254 192 253 121 201 154 167 141 248 198 181 71 151 165 144 191 239 212 195 78 76 63 57 117 11 164 127 77 128 2 161 49 184 112 255 142 101 198 195 123 117 229 197 76 138 43 194 253 172 237 180 31 48 237 139 201 2 152 25 183 6 75 101 20 161)
#t
())
#(7
""
#vu8(224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255)
#vu8(65 250 144 125 169 247 142 16 123 88 255 108 74 192 233 42 155 188 127 91 81 2 96 87 47 206 78 240 71 199 60 171 63 176 208 11 53 59 76 185 37 109 221 173 67 44 88 21 101 43 216 60 120 230 87 7 87 129 20 13 229 97 137 236 251 225 96 31 36 189 206 5 198 63 81 26 61 4 103 61 36 196 233 67 105 93 120 18 170 214 111 55 74 116 169 6 23 125 199 41 9 0 112 203 93 109 81 142 112 69 244 205 236 224 108 226 174 66 225 23 124 70 133 106 132 37 230 11 176 96 64 64 12 139 160 239 184 212 243 149 164 55 125 76 44 18 140 104 230 179 14 53 138 115 217 144 77 122 161 229 23 239 57 101 38 203 100 211 155 59 54 237 114 4 179 186 177 217 27 35 202 149 178 202 29 163 238 233 28 125 39 180 228 230 88 251 245 6 10 121 204 230 155 225 217 82 82 176 215 215 34 7 151 165 57 130 220 55 19 114 150 157 78 6 85 101 7 231 231 135 10 158 253 158 3 118 103 2 242 23 190 28 143 127 128 0 108 8 209 62 23 80 64 207 40 178 21 222 172 106 30 191 53 32 163 173 158 145 249 7 45 254 80 198 157 26 165 160 223 115 173 99 247 40 49 176 85 242 54 126 163 92 254 103 106 79 121 112 188 133 226 181 137 23 209 189 68 158 211 210 116 172 64 247 165 21 226 97 223 61 6 122 39 122 230 16 228 238 76 246 139 58 148 122 232 200 51 156 129 142 209 14 115 182 72 5 119 178 161 55 34 2 60 187 9 211 179 120 207 183 31 108 134 189 72 30 224 154 31 203 184 7 51 142 150 138 165 175 153 54 151 234 181 98 170 73 117 86 46 234 107 17 105 232 108 117 239 19 232 119 207 205 70 8 153 78 173 237 234 62 186 85 175 25 167 165 91 25 233 43 151 68 80 165 147 205 231 23 191 13 125 219 240 187 232 254 249 8 22 254 207 134 236 82 42 45 6 160 78 187 197 10 30 175 214 122 164 97 168 169 205 112 94 206 11 187 70 207 119 54 137 204 25 205 105 96 117 148 253 46 189 224 106 170 30 52 235 236 0 30 223 49 143 162 34 69 135 100 97 252 70 18 97 114 219 65 174 158 205 116 112 14)
#t
())
#(8
"Legacy:missing NULL"
#vu8(49 50 51 52 48 48)
#vu8(23 79 54 68 245 56 12 157 128 66 135 216 181 132 53 207 20 18 131 238 191 235 78 55 100 147 180 1 184 18 181 37 220 167 8 51 253 246 38 176 67 231 10 113 169 165 73 116 190 75 119 184 250 192 200 205 139 81 65 235 76 138 144 108 177 101 132 179 133 18 79 45 51 144 53 144 101 114 228 70 210 48 203 96 160 96 78 83 69 77 141 12 252 88 140 4 145 25 14 44 38 244 98 52 188 224 129 170 178 194 207 21 205 29 118 75 175 70 253 139 21 78 117 232 190 133 213 76 11 144 98 238 38 110 46 199 129 247 219 190 135 100 236 205 19 218 92 16 123 70 130 149 144 246 242 143 89 94 244 222 55 68 5 15 162 247 33 195 251 225 175 232 37 0 105 216 21 198 50 115 207 206 183 117 5 254 197 132 76 33 173 142 96 167 49 73 229 215 195 1 136 149 150 122 190 71 29 124 192 128 0 48 199 7 96 189 13 61 72 214 30 126 177 42 10 39 169 22 119 33 109 0 149 162 169 90 55 243 200 105 66 193 152 29 222 79 120 151 164 25 10 39 14 150 46 43 164 39 180 230 48 227 24 122 180 44 187 63 154 172 201 192 242 234 201 168 196 79 109 115 249 110 171 52 183 77 187 160 102 201 221 86 211 43 167 223 8 125 186 158 71 149 130 191 115 213 148 28 193 7 202 213 92 101 150 212 226 94 57 167 238 55 4 34 142 249 120 48 118 5 242 135 46 174 35 216 242 252 93 140 8 139 72 46 21 173 237 162 42 124 171 157 0 87 141 20 61 83 175 39 176 68 22 161 195 132 26 168 141 230 220 79 22 184 221 50 8 151 209 73 142 78 255 181 138 109 135 184 221 205 207 174 238 117 236 185 239 100 227 219 98 194 50 150 95 85 110 227 247 77 115 210 177 153 147 233 169 184 214 186 86 204 135 251 190 59 127 183 221 203 53 24 78 226 184 129 213 94 85 167 128 58 178 220 221 205 53 114 203 137 33 190 223 149 129 133 238 112 70 177 46 244 230 25 10 49 64 18 0 111 128 3 172 169 63 67 13 18 29 241 173 163 22 255 224 177 239 133 112 110 54 173 33 100 205 30 64 56 155 47 54 207 16 115 94 104 225 80 34 9 120 132)
#t
("MissingNull"))
#(9
"long form encoding of length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(52 224 28 207 136 183 178 94 213 111 95 175 200 157 220 185 182 250 222 129 237 36 70 176 193 51 246 148 158 115 161 214 129 52 151 63 89 165 81 88 43 179 194 134 81 179 79 255 119 249 126 145 217 71 169 111 38 155 174 243 85 105 126 21 244 153 157 59 139 23 60 102 200 110 170 84 107 68 241 170 66 37 29 244 85 132 169 56 180 12 111 27 94 31 140 88 255 116 249 98 87 160 68 177 10 112 188 80 117 249 118 156 60 148 157 205 232 137 227 185 198 211 45 78 238 110 49 45 250 44 116 49 137 84 119 5 86 103 125 25 55 38 94 137 107 240 68 179 192 160 58 198 239 29 130 136 138 90 1 7 135 220 74 101 168 85 54 133 50 176 146 165 246 201 133 221 114 9 102 252 212 7 212 101 179 52 38 205 110 86 172 48 254 255 7 59 212 197 81 21 189 186 239 113 193 79 24 15 181 89 250 72 96 215 188 148 181 42 172 141 18 29 12 10 228 194 166 78 227 45 26 16 134 239 219 66 100 244 249 63 78 141 176 150 114 79 82 214 8 188 104 110 181 95 62 40 32 171 196 56 74 246 228 228 168 249 236 164 203 62 82 196 58 103 230 115 242 97 13 237 105 223 82 15 236 118 211 170 80 185 166 85 111 206 194 4 203 149 154 14 191 166 223 184 104 6 143 88 51 56 229 124 220 194 210 96 58 206 220 72 197 149 0 69 53 34 191 168 22 92 142 44 99 228 172 151 179 212 215 0 117 200 87 190 255 181 219 141 245 130 71 236 72 66 253 160 138 9 61 245 221 174 28 173 3 227 116 163 80 168 121 97 64 139 244 250 153 229 81 27 164 42 144 89 160 237 115 193 201 97 138 224 163 0 57 147 71 238 25 64 3 251 129 246 233 5 240 40 110 20 103 252 14 239 44 86 145 192 208 90 72 14 82 236 87 143 119 210 97 101 3 6 21 48 222 19 70 209 164 36 250 205 44 187 154 124 141 163 141 135 14 95 75 140 212 6 212 20 33 201 89 16 28 110 238 230 14 9 43 42 93 199 23 242 202 242 146 200 98 45 144 56 86 162 102 227 28 124 52 43 191 9 248 188 55 246 127 87 106 62 139 150 59 136 235 218 154 163 29 9 63 217)
#f
())
#(10
"long form encoding of length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(93 160 147 2 253 46 110 176 105 95 45 2 120 147 244 45 113 71 107 208 173 142 23 131 243 1 95 218 61 27 93 79 172 27 86 251 241 51 20 75 248 47 135 65 96 163 162 72 226 198 164 218 105 26 125 178 17 14 75 208 149 213 54 231 47 189 227 180 124 224 189 204 162 252 144 80 170 175 35 149 104 111 152 184 218 131 167 173 21 43 47 81 113 37 132 59 131 6 130 138 13 94 248 212 179 171 184 116 55 54 68 232 23 85 231 169 41 163 62 152 6 156 77 77 10 115 43 101 197 184 54 194 183 255 198 169 20 206 2 194 172 13 75 213 230 127 122 57 93 160 77 143 36 3 29 27 218 215 62 237 157 8 152 34 22 170 197 160 103 217 3 17 191 252 43 16 159 157 195 171 78 226 192 81 226 56 128 166 117 250 177 90 60 238 191 21 241 20 215 149 35 234 87 128 214 42 7 133 202 221 211 211 69 105 123 138 26 120 91 20 136 234 236 187 134 63 139 162 42 48 123 200 53 243 200 50 206 55 222 71 164 22 19 107 140 46 85 155 56 254 141 43 148 196 205 55 111 190 32 145 48 32 107 83 39 31 105 120 155 208 242 89 107 133 217 204 176 0 161 94 63 46 124 80 232 130 13 171 219 54 177 223 172 131 207 10 48 126 228 110 202 20 46 183 71 221 114 151 47 14 130 78 145 7 243 24 3 110 131 39 74 222 85 213 63 180 112 105 204 73 204 81 70 15 152 44 183 18 7 64 130 85 155 239 67 108 80 28 150 142 27 115 250 228 173 174 95 45 113 17 161 116 29 18 153 134 155 95 93 108 131 28 105 196 171 50 60 78 4 34 126 67 92 243 203 251 161 163 169 230 230 166 67 104 2 125 92 56 90 203 171 0 18 243 133 255 163 49 219 93 236 211 88 212 74 254 77 125 4 124 164 236 155 143 136 137 48 193 198 202 26 1 16 108 143 116 130 237 128 206 207 14 36 78 231 110 40 82 125 132 100 244 19 149 233 73 237 167 78 35 50 130 245 11 111 204 237 221 52 120 190 139 120 37 172 5 240 241 240 150 23 243 31 121 234 207 16 217 11 229 7 17 184 210 192 164 225 242 6 42 61 109 74 185 237 5 192 246 103 143 148 231)
#f
())
#(11
"length of sequence contains leading 0"
#vu8(49 50 51 52 48 48)
#vu8(16 135 122 231 166 58 102 184 36 158 52 85 124 36 20 92 74 91 188 225 178 215 25 30 216 166 177 148 181 161 76 111 12 117 225 87 119 44 144 85 54 50 196 165 134 54 174 195 86 229 11 177 80 53 183 64 144 132 186 104 233 29 9 207 163 208 144 225 180 225 124 8 197 106 61 32 251 235 212 131 223 152 75 95 128 12 119 36 197 44 25 51 157 182 47 249 177 59 44 179 139 17 135 197 146 127 254 87 40 184 199 166 109 63 32 157 179 226 164 144 177 21 230 232 84 187 139 95 182 227 144 174 219 90 199 252 147 146 19 153 130 65 32 162 76 109 254 139 8 72 69 228 146 28 91 220 4 240 211 249 220 215 137 102 50 37 43 105 114 121 150 179 37 233 154 7 253 218 240 85 50 134 133 3 91 98 156 0 16 120 200 24 46 75 199 145 85 64 90 172 35 36 121 4 151 202 8 46 13 158 107 39 7 160 17 169 83 15 237 15 176 226 86 138 5 171 38 227 205 30 97 61 108 244 241 14 230 25 249 123 235 255 89 223 99 68 39 88 78 38 250 129 207 142 254 7 196 14 185 16 167 203 228 99 235 86 140 188 12 177 153 33 70 251 215 40 0 100 168 24 157 34 238 35 40 63 102 27 158 152 13 36 3 231 7 83 193 188 167 80 94 201 44 29 104 130 0 254 0 29 89 120 116 150 141 20 168 243 216 237 190 67 106 111 115 40 33 139 105 149 123 21 38 210 46 234 112 153 46 209 69 38 160 65 94 18 83 74 244 67 161 216 16 5 120 190 136 139 173 94 47 161 134 56 215 125 197 235 23 127 187 18 4 93 107 178 252 112 189 74 195 217 243 162 2 80 54 17 239 107 85 176 5 246 163 156 244 94 58 137 108 90 114 111 142 236 26 213 182 134 36 52 123 224 180 86 29 246 138 252 187 214 101 147 91 75 82 25 215 90 240 37 40 73 174 75 220 154 232 150 54 247 208 189 149 51 176 161 143 148 250 46 197 180 196 252 182 58 8 128 97 154 136 123 113 12 185 43 51 118 164 7 251 198 251 196 61 87 148 221 36 60 125 35 90 20 232 204 62 79 120 108 59 213 127 57 19 147 208 92 40 59 217 198 33 4 254 4 206 242 156 117)
#f
())
#(12
"length of sequence contains leading 0"
#vu8(49 50 51 52 48 48)
#vu8(189 149 134 245 47 46 20 176 105 74 68 127 193 17 8 97 65 248 134 79 13 36 100 237 131 173 238 176 183 2 204 13 197 1 184 153 240 193 186 90 203 12 1 99 25 29 200 244 110 38 99 31 162 54 40 153 2 148 156 8 126 244 150 133 133 169 218 221 172 0 253 244 67 5 97 253 129 96 95 127 53 104 34 45 163 196 205 221 185 4 125 213 41 82 122 93 55 12 52 61 210 5 141 61 211 136 81 87 228 89 77 122 241 96 226 68 50 151 163 200 124 66 20 174 58 226 251 60 19 168 255 57 225 232 4 251 179 159 48 151 176 151 167 210 221 86 141 136 90 90 189 195 209 187 1 35 73 117 142 150 182 8 5 2 133 173 60 128 19 35 144 174 95 201 237 218 196 12 169 141 109 182 70 59 143 16 247 158 76 74 152 210 170 145 183 216 214 185 194 83 109 129 49 163 212 71 169 98 36 103 231 23 12 102 199 36 149 223 63 140 236 17 149 29 179 204 100 7 206 117 239 57 133 129 103 119 83 119 59 206 182 174 206 68 244 2 146 216 222 21 224 32 82 54 68 172 240 175 199 158 19 129 135 91 106 103 22 139 245 102 102 92 74 74 171 26 140 106 42 56 68 55 244 205 43 36 42 204 141 131 133 203 57 118 77 171 44 115 226 71 98 0 194 19 110 73 4 248 186 4 121 229 166 236 227 138 200 180 233 155 107 228 162 241 35 16 178 101 168 71 6 40 249 209 152 216 151 202 206 110 253 156 194 184 189 41 150 150 101 74 226 5 225 71 5 33 236 126 199 77 44 255 253 5 138 27 209 248 77 114 165 225 61 43 244 74 168 48 109 120 49 149 105 99 93 73 44 99 147 151 216 134 34 45 93 228 111 130 220 197 189 151 54 212 1 186 41 32 87 123 199 30 124 238 119 185 57 87 50 49 123 132 157 34 234 152 189 92 110 228 97 216 39 93 244 250 138 154 202 173 195 219 82 141 124 83 232 183 231 151 230 100 125 223 158 34 89 175 131 180 197 109 99 188 169 1 225 240 206 84 20 181 96 159 193 237 205 42 106 113 33 180 26 47 48 130 167 186 111 204 99 15 188 127 255 75 194 83 89 32 214 232 52 94 10 168 214 36 10 95 4 241)
#f
())
#(13
"wrong length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(35 218 36 91 193 222 255 240 157 196 160 173 197 131 71 206 65 145 9 227 0 47 209 48 3 49 168 223 189 230 143 75 23 215 230 91 142 202 170 105 171 193 65 52 66 43 118 3 111 73 23 183 217 145 224 245 29 22 128 116 114 42 47 28 205 27 48 187 214 243 19 159 20 125 41 239 17 160 218 18 4 212 173 17 93 246 122 102 212 209 5 9 171 234 253 37 2 166 182 113 164 7 70 134 23 81 231 229 145 46 35 219 5 208 179 235 250 149 240 243 255 248 135 107 111 1 175 61 195 213 233 76 204 117 130 83 109 239 157 64 250 203 44 109 145 224 234 239 62 247 117 63 168 131 12 113 230 229 131 250 33 212 35 205 172 71 24 147 55 248 204 166 16 68 228 146 176 115 202 238 151 92 211 205 51 235 213 72 238 230 141 114 32 252 231 139 162 219 23 239 138 228 135 210 255 6 233 77 61 74 230 126 63 249 211 215 130 86 64 55 68 223 193 140 86 73 213 41 243 40 59 81 237 215 129 124 195 238 154 61 65 125 78 46 88 63 19 163 107 221 201 63 7 140 223 189 251 161 200 204 72 107 80 232 16 79 77 200 98 212 207 255 199 201 32 145 67 212 63 215 213 89 24 211 38 240 34 219 131 109 109 58 225 85 137 122 164 161 42 247 136 70 201 78 27 180 32 37 167 150 213 148 146 0 17 148 90 167 215 244 30 172 140 10 66 37 34 134 38 116 51 192 64 147 113 210 14 49 36 35 6 45 234 67 82 131 211 133 122 86 209 180 114 72 25 11 115 179 88 236 188 153 142 125 250 164 244 184 154 205 16 176 91 88 161 114 250 88 253 55 240 123 112 122 151 138 164 226 109 71 23 38 36 14 220 229 34 212 8 52 119 219 55 228 226 48 3 28 240 96 150 211 115 214 94 78 127 218 71 212 33 228 208 0 183 34 218 99 38 217 232 250 95 9 242 104 95 106 243 165 31 86 73 233 154 103 1 11 251 105 95 63 91 216 166 2 122 177 235 117 158 240 160 34 245 189 103 117 229 254 150 170 34 217 215 107 55 83 119 226 181 86 25 156 148 15 5 103 240 152 153 135 78 2 232 185 114 148 15 199 215 253 99 46 250 151 166 23 193 212 118 126)
#f
())
#(14
"wrong length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(190 196 236 193 233 147 93 38 168 164 72 38 106 109 69 14 241 146 109 62 3 83 187 97 247 216 73 52 215 198 109 102 180 68 29 33 181 74 186 249 32 2 87 252 168 154 211 82 251 2 71 181 182 95 201 82 244 215 95 223 210 192 74 139 68 8 23 207 53 28 76 9 73 49 145 237 228 215 60 165 93 65 66 241 200 171 209 152 34 120 198 12 47 159 95 42 223 74 13 30 10 216 234 46 58 161 119 138 132 106 145 188 244 186 75 150 55 228 162 174 73 237 145 55 156 33 39 220 224 254 3 4 142 120 220 156 55 183 0 8 154 184 75 132 207 247 135 47 224 141 13 119 56 24 225 88 184 150 187 214 7 90 246 223 26 117 25 9 221 30 93 173 150 142 204 145 188 98 25 198 19 164 171 144 45 230 176 172 196 103 72 163 15 239 159 179 58 51 88 32 215 55 253 179 83 249 232 229 55 142 156 236 237 91 136 9 144 109 219 113 0 56 198 242 196 227 200 1 88 245 234 74 177 226 53 123 238 127 1 226 221 45 200 30 153 18 216 178 96 239 74 211 142 24 29 127 45 91 7 40 118 89 224 51 81 228 206 224 240 205 78 76 164 119 65 85 4 168 229 145 104 147 121 88 227 234 221 160 169 227 102 252 55 12 48 138 215 133 5 168 250 202 65 110 148 183 242 127 96 244 7 9 149 159 226 108 28 106 185 133 161 20 21 55 209 250 17 12 206 17 90 228 90 16 163 73 133 145 128 14 129 16 32 151 255 81 69 81 129 154 191 171 103 216 118 223 55 225 208 69 87 202 152 172 109 156 20 205 224 189 46 15 156 207 214 226 87 23 80 179 166 149 25 255 38 48 197 241 160 143 34 118 126 149 0 114 116 51 18 106 125 168 93 153 44 209 77 77 148 106 175 235 89 111 122 168 234 34 57 209 213 252 5 86 88 70 105 168 254 150 140 125 30 201 243 90 96 26 252 125 140 94 38 32 175 91 185 95 217 34 223 179 184 208 19 245 184 124 60 177 218 75 51 73 171 19 19 90 19 212 93 228 155 73 145 238 254 140 111 107 27 212 9 178 248 39 40 137 134 233 134 207 8 198 67 66 11 22 10 100 45 196 122 251 122 243 33 217 238 232 154 247)
#f
())
#(15
"wrong length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(110 90 68 180 254 82 200 16 78 182 14 125 150 230 151 194 251 12 118 16 254 23 254 140 109 16 250 188 80 156 211 203 22 187 68 40 147 94 197 143 172 132 219 131 84 43 161 102 153 31 146 58 152 137 238 120 8 143 8 134 222 238 16 124 29 8 82 235 203 41 85 97 195 151 123 45 105 170 6 158 28 21 228 29 90 196 112 80 178 34 25 98 65 63 155 81 17 165 54 160 166 193 118 45 4 221 138 217 99 24 150 78 52 184 35 5 100 80 158 98 214 59 75 253 13 204 175 239 195 27 196 74 0 134 218 174 93 168 155 175 153 14 69 79 57 3 67 241 117 95 125 178 188 234 239 10 49 13 7 183 129 122 41 55 20 133 213 171 206 28 185 177 229 86 184 48 225 91 53 222 11 10 169 119 174 177 182 165 65 23 189 120 127 127 154 100 69 33 35 163 242 159 194 232 114 86 57 81 2 182 172 134 191 222 33 192 90 90 235 212 134 32 8 190 121 234 227 79 170 243 36 219 9 181 188 87 231 226 101 11 162 213 161 24 81 239 140 134 77 197 192 76 88 177 50 194 8 183 197 121 103 59 116 25 85 125 75 189 180 123 34 129 18 156 114 7 45 144 110 14 99 244 230 221 85 243 211 178 252 56 106 129 167 183 70 169 145 167 81 212 157 145 167 111 164 135 107 60 147 196 184 230 189 147 38 149 121 148 53 76 228 217 61 201 61 245 197 168 209 21 137 125 38 56 87 199 2 242 169 95 244 167 20 212 2 200 139 7 202 164 61 72 118 174 92 55 120 10 122 34 160 30 143 90 137 238 27 80 24 90 39 49 129 32 166 211 218 209 86 129 30 232 24 250 45 123 5 29 87 197 164 249 185 58 153 219 233 99 11 62 48 30 148 176 79 246 191 212 54 26 188 217 93 134 252 137 4 111 102 218 128 226 144 115 54 95 203 190 240 231 242 158 167 153 227 51 2 238 58 41 121 39 66 244 160 120 246 207 134 73 76 151 232 177 220 32 24 212 166 95 250 202 33 175 67 103 90 100 97 164 168 81 158 149 244 50 14 44 233 4 248 142 232 191 204 93 16 169 128 104 74 32 56 179 220 139 52 181 19 25 149 198 132 200 157 1 9 91 65 183 19 190)
#f
())
#(16
"wrong length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(133 106 204 198 66 14 148 12 182 174 73 0 154 252 70 188 67 206 72 83 9 138 37 99 29 23 44 48 178 217 75 113 38 137 73 200 236 183 33 162 79 29 155 29 208 68 143 40 37 38 140 63 98 195 154 151 212 11 187 54 204 147 243 111 158 120 193 232 122 231 226 23 163 240 243 185 108 32 185 156 150 209 13 138 6 180 13 171 117 231 4 95 72 75 214 83 118 16 244 35 52 93 244 185 35 91 231 8 116 195 117 77 201 19 26 213 4 29 167 206 124 97 237 231 137 216 122 218 200 93 201 49 139 130 152 92 131 20 62 161 25 76 7 56 110 207 46 58 244 193 167 39 34 193 150 73 135 83 120 180 62 133 184 37 30 118 158 66 64 95 112 174 38 217 78 123 116 146 220 118 26 204 249 215 147 245 185 227 97 154 129 146 216 22 110 204 83 103 157 194 189 27 143 246 9 214 152 191 146 199 90 201 40 149 101 60 101 10 178 5 169 35 50 55 197 239 17 29 113 205 19 174 44 171 230 199 31 81 100 232 150 233 101 154 254 84 126 209 50 26 108 248 71 52 188 204 25 185 185 61 121 107 84 238 111 63 83 85 191 26 143 104 24 84 173 166 60 168 190 175 150 149 197 218 154 219 23 5 239 6 179 191 207 45 53 190 119 147 196 140 141 141 50 161 226 39 55 20 195 20 103 4 71 197 16 101 97 149 88 200 174 128 239 40 96 72 206 215 229 61 60 123 82 147 209 20 91 51 122 14 195 75 33 219 211 226 186 196 137 123 198 87 115 112 68 201 235 248 201 216 206 130 163 58 86 120 90 47 33 194 150 177 132 53 137 80 5 209 165 190 248 196 150 163 108 70 8 185 247 223 241 59 199 167 65 33 123 84 184 41 62 139 117 78 31 29 152 249 173 116 189 51 52 243 129 114 111 64 81 48 80 155 129 91 203 9 243 75 60 52 179 52 8 112 231 112 43 84 223 171 129 254 104 194 14 29 110 201 246 77 219 183 62 240 118 143 62 216 11 171 191 202 126 175 230 156 203 225 188 141 181 14 211 86 20 241 184 131 231 2 192 70 18 175 135 254 60 244 128 99 6 138 188 66 243 223 190 100 153 184 250 165 122 183 83 132 187 196 124 10 131 187)
#f
())
#(17
"uint32 overflow in length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(118 88 234 191 68 203 245 119 127 18 28 69 156 135 116 74 238 85 181 32 243 22 63 151 83 215 194 29 100 135 218 188 203 221 106 84 189 129 134 204 92 214 143 222 118 230 234 186 70 68 62 192 167 80 161 130 78 127 142 117 129 247 181 121 73 204 108 68 181 166 188 8 214 17 120 97 124 78 233 158 199 0 5 53 98 239 238 61 140 125 83 32 130 206 165 38 246 224 148 155 104 99 153 241 86 88 119 25 73 207 110 168 235 69 85 135 253 50 141 225 49 81 128 223 20 155 247 100 206 82 83 108 130 178 209 233 36 231 183 205 192 157 17 247 232 232 225 39 156 254 189 57 184 221 100 144 34 6 227 254 67 118 151 176 205 226 98 13 166 243 37 45 9 226 206 181 42 107 177 166 59 64 125 62 241 160 236 45 109 254 122 65 61 216 232 153 184 218 35 128 50 36 21 20 180 74 221 7 226 163 207 55 206 233 203 213 11 189 236 211 134 34 107 8 2 6 82 187 101 30 41 47 180 221 246 160 207 140 58 207 155 161 58 217 14 116 5 84 24 214 207 14 194 222 228 79 186 32 122 32 82 71 76 110 57 122 126 179 10 2 29 46 68 179 67 98 70 87 212 117 55 6 223 137 59 3 19 149 208 207 216 49 234 228 119 117 178 164 238 33 187 54 242 148 242 106 27 161 1 29 22 213 168 137 237 253 240 246 158 59 204 16 216 93 216 159 84 49 138 166 64 63 250 13 211 113 21 22 160 209 55 113 240 74 35 199 103 154 47 234 210 12 87 240 103 233 254 181 244 55 41 191 99 81 238 59 218 114 13 95 1 213 102 136 236 43 213 247 96 151 123 234 177 75 34 187 114 136 94 43 127 67 87 44 11 253 164 51 235 101 232 248 199 218 129 65 79 150 69 79 222 51 206 182 119 90 231 62 225 25 226 90 143 84 169 207 51 146 47 176 109 239 18 198 198 227 205 240 17 52 166 42 129 65 42 203 103 183 230 55 120 214 117 209 16 216 251 238 243 61 176 84 115 124 156 153 184 96 65 233 106 19 191 6 66 100 211 171 189 230 90 245 152 205 96 170 130 127 79 116 22 211 243 176 198 34 192 56 199 251 99 234 124 16 105 30 73 0 240 80 90 5)
#f
())
#(18
"uint32 overflow in length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(91 223 37 179 75 4 82 146 141 86 22 20 13 174 214 44 183 145 98 131 22 87 34 169 143 52 78 47 184 96 40 244 165 166 69 146 39 80 47 85 138 176 230 208 89 31 40 187 175 199 251 171 90 84 17 22 122 205 113 131 147 109 7 44 49 146 215 58 175 95 2 173 77 49 208 175 236 104 106 108 108 115 203 4 38 196 50 11 87 183 60 246 220 204 42 55 109 12 218 162 176 248 111 154 172 107 220 55 0 229 223 122 117 254 105 136 30 62 5 115 22 127 59 143 171 163 215 190 33 99 94 125 209 12 232 44 124 183 78 151 97 20 21 247 226 131 189 172 75 24 111 123 12 78 158 128 58 159 25 34 15 104 102 87 48 14 78 195 18 34 159 248 207 105 251 120 9 100 209 76 54 84 223 121 144 63 174 153 105 5 133 51 167 208 252 41 244 23 249 140 28 98 174 231 235 38 10 49 132 4 230 65 100 105 157 24 161 107 219 147 78 91 234 173 81 61 107 183 189 241 243 12 137 238 188 44 192 46 98 58 167 245 37 50 242 232 145 34 245 10 216 190 156 211 214 71 109 129 94 114 27 120 159 20 139 226 84 115 30 77 82 54 166 120 165 137 75 147 157 232 128 103 168 247 12 63 245 53 91 122 16 194 166 36 208 159 173 255 226 156 151 230 194 182 85 178 44 188 143 153 161 145 37 57 208 52 83 127 41 195 67 233 77 118 36 150 237 147 7 41 64 188 45 86 188 65 157 197 132 224 249 132 188 219 70 129 146 13 101 14 172 123 172 12 242 173 20 69 117 102 220 178 196 22 88 19 174 228 210 137 26 223 137 121 191 56 230 215 163 184 0 115 186 4 195 91 45 22 21 117 237 186 23 82 15 167 9 226 241 173 142 228 63 245 50 127 184 244 9 53 183 86 60 10 20 135 112 30 150 75 40 44 62 94 41 75 93 92 181 112 209 129 8 194 216 251 159 158 36 25 188 21 78 31 134 91 37 18 188 255 36 36 166 144 175 182 208 245 130 244 184 74 65 228 162 17 254 87 172 64 109 181 144 138 201 90 90 38 215 222 108 61 123 75 39 212 167 145 156 131 98 41 62 140 141 254 33 103 94 128 7 148 211 28 185 109 154 64 12 21 223 75)
#f
())
#(19
"uint64 overflow in length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(32 220 9 214 151 129 57 237 191 181 112 161 122 57 112 74 102 43 119 254 64 71 3 114 117 6 67 70 231 97 242 225 152 4 106 66 186 25 8 127 191 95 68 151 118 21 168 195 210 105 80 172 185 158 241 170 187 50 169 154 90 6 155 167 0 138 15 133 148 196 251 215 1 13 220 221 113 194 245 189 42 201 114 212 242 67 76 198 98 68 62 40 15 46 36 31 12 54 237 71 194 118 86 55 99 208 149 145 200 13 28 119 251 31 210 202 39 132 72 243 209 131 253 193 111 29 154 205 189 249 76 122 36 8 235 183 189 56 131 118 127 253 95 122 57 43 161 148 92 42 185 176 61 168 80 231 69 67 47 10 9 199 192 46 112 101 200 181 92 63 248 107 23 27 120 177 60 58 185 51 234 26 118 195 50 162 105 12 133 47 75 195 158 126 140 191 248 215 31 29 46 97 76 97 30 74 197 185 246 52 15 173 29 179 163 72 79 183 162 149 249 231 103 59 186 168 237 103 93 164 145 94 170 240 179 203 136 46 155 144 85 174 75 184 202 81 55 98 199 58 120 241 47 66 191 60 196 44 142 55 238 192 111 124 175 29 165 202 217 44 218 40 77 7 222 117 170 233 104 28 196 204 153 116 226 104 61 74 86 166 175 108 121 47 38 162 129 231 45 244 94 227 178 190 235 118 103 226 178 84 64 92 58 249 40 137 230 173 211 122 172 210 230 241 221 177 6 209 231 222 144 31 40 94 199 9 123 21 137 132 67 216 243 104 160 117 108 44 147 126 241 236 23 119 54 233 64 67 104 157 106 176 74 188 215 130 157 88 232 136 51 95 198 77 25 120 62 240 133 68 250 224 239 92 218 119 30 72 18 23 192 158 187 193 46 65 152 31 86 182 140 76 144 120 23 47 87 89 40 199 0 54 6 246 156 61 117 239 43 57 125 221 184 86 173 86 37 3 92 39 75 91 253 214 238 145 4 94 184 174 241 80 4 22 11 152 132 108 129 124 187 232 230 8 251 20 38 218 255 148 30 159 13 53 138 190 249 216 181 43 89 211 210 95 244 26 68 205 17 104 230 172 50 240 158 134 86 154 223 61 209 28 99 42 209 76 67 164 84 85 117 244 70 27 204 41 18 44 191 175 84 64)
#f
())
#(20
"uint64 overflow in length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(56 12 83 52 24 89 98 190 249 238 138 208 103 43 75 153 127 160 209 190 63 173 99 0 115 45 237 226 105 126 89 0 35 12 100 249 62 192 147 38 62 98 174 234 118 117 66 35 172 201 63 170 206 213 62 85 138 113 71 181 96 188 25 99 134 66 221 216 45 27 36 10 121 131 191 45 124 112 185 134 190 92 248 90 186 242 139 81 89 158 141 61 80 212 154 186 237 232 137 173 6 100 73 130 170 1 13 134 243 249 233 51 36 67 188 238 104 93 217 13 43 136 162 107 65 164 187 54 117 182 36 40 54 161 104 145 125 34 165 238 189 162 128 13 101 195 61 167 145 195 190 251 178 188 114 161 121 118 192 39 104 111 150 118 50 173 148 189 220 172 5 89 232 47 206 105 24 88 143 129 77 207 101 204 49 55 52 77 216 74 232 44 0 70 147 8 236 98 233 220 186 250 80 31 214 9 30 5 136 138 40 24 11 132 1 165 162 9 135 2 229 188 60 138 33 143 96 133 134 193 37 44 181 239 129 191 236 21 65 152 240 226 175 105 147 228 173 87 237 216 247 79 18 18 247 5 9 180 89 177 5 133 132 70 59 150 146 87 35 193 233 83 112 134 53 104 135 180 80 219 133 37 208 79 78 83 168 116 176 145 158 102 63 201 191 139 210 132 137 134 5 77 86 243 118 111 190 170 197 80 86 92 135 54 182 92 139 33 205 104 195 73 120 82 191 188 111 156 131 244 142 120 127 207 43 226 68 1 123 239 157 230 198 51 210 144 107 195 162 144 126 187 193 119 174 182 133 226 255 178 91 226 147 60 57 228 38 237 40 4 110 176 109 217 240 47 191 19 56 135 252 147 11 68 206 181 42 126 69 1 29 28 236 118 212 147 115 153 207 95 83 16 204 9 248 71 192 78 250 233 42 168 5 67 190 137 61 171 43 5 195 12 155 70 221 143 7 93 77 3 168 245 198 192 127 5 156 116 15 213 87 164 6 245 20 117 115 169 217 44 10 131 46 226 89 89 35 151 96 202 4 83 236 26 234 138 28 106 43 51 45 42 151 0 35 107 151 91 105 118 64 8 44 105 116 4 124 178 211 211 153 104 118 18 2 112 20 32 72 110 30 39 28 94 228 149 238 183 150 123 252 214)
#f
())
#(21
"length of sequence = 2**31 - 1"
#vu8(49 50 51 52 48 48)
#vu8(179 32 36 232 138 40 254 252 2 46 77 84 235 94 130 11 92 226 5 212 234 171 200 125 60 141 209 135 124 209 99 177 187 251 61 61 41 195 218 120 185 141 49 242 71 142 140 243 30 82 56 161 210 132 155 57 212 240 116 236 60 169 107 188 228 199 54 79 154 20 200 62 54 58 193 122 54 228 45 219 246 31 182 99 138 3 7 243 254 180 104 239 82 107 11 30 29 35 3 15 198 235 50 63 64 92 62 52 207 33 30 89 103 200 216 74 196 54 209 239 114 38 80 17 126 181 247 77 78 198 225 104 187 253 167 227 114 193 173 130 129 96 147 112 103 207 11 237 137 57 184 175 34 137 88 63 69 158 106 46 67 170 148 42 120 171 129 28 95 114 12 219 146 207 99 87 249 149 220 60 23 107 233 129 206 78 134 190 59 99 188 213 202 132 56 32 49 241 100 64 200 205 186 244 50 125 145 65 102 175 34 50 30 205 170 2 218 143 170 18 165 82 45 231 118 242 63 249 2 75 96 68 107 202 13 164 94 94 52 142 207 235 183 200 94 228 149 44 246 181 67 1 155 92 252 145 8 217 237 171 237 118 27 133 34 228 147 84 254 207 221 178 79 224 129 84 37 11 37 36 218 231 97 40 243 54 79 120 0 138 65 77 12 1 188 227 32 179 46 143 216 188 130 13 69 152 229 168 24 1 76 248 206 177 25 233 145 114 44 149 226 228 56 15 102 211 231 162 233 107 73 207 224 109 186 38 179 198 235 77 103 242 198 26 152 100 196 2 48 223 80 183 132 20 91 228 10 208 103 192 172 187 252 252 13 112 107 135 19 112 32 49 125 93 92 237 192 187 170 236 64 193 107 89 0 84 30 178 194 222 233 34 127 105 160 6 219 5 84 183 234 187 214 245 120 155 221 191 188 13 114 155 195 103 89 203 35 196 124 185 176 66 130 70 53 29 37 71 53 217 40 22 248 241 204 27 178 227 3 15 184 222 192 40 175 71 58 100 57 151 214 33 176 106 171 117 216 38 30 157 110 23 167 241 194 34 234 123 79 92 66 4 161 255 191 96 167 161 152 159 205 14 154 204 254 143 83 237 3 220 110 192 78 228 255 220 26 182 59 88 17 55 171 172 89 149 175 199 197 43 17 183)
#f
())
#(22
"length of sequence = 2**31 - 1"
#vu8(49 50 51 52 48 48)
#vu8(10 149 9 48 33 188 21 171 123 225 41 71 232 146 252 114 241 47 92 183 102 0 238 58 220 14 83 109 204 189 210 53 17 6 88 255 125 29 99 178 66 185 228 28 228 214 216 210 15 254 172 181 154 134 218 183 245 114 147 40 211 245 217 216 134 232 141 52 71 136 204 216 172 77 172 237 61 76 126 239 181 114 112 55 213 192 115 179 171 210 33 201 82 7 242 247 52 78 244 255 149 255 214 90 151 244 198 10 58 117 144 26 97 108 154 240 117 113 187 188 37 169 234 63 92 175 64 188 39 144 200 36 182 179 22 133 252 146 67 139 115 82 38 193 162 247 48 235 133 150 149 75 225 55 24 46 233 191 11 166 134 6 0 108 38 45 123 36 54 12 180 192 141 213 224 209 68 248 240 202 233 77 105 26 236 145 224 239 193 201 45 1 40 237 153 234 125 218 227 187 188 219 177 102 148 133 89 58 83 19 172 66 242 115 82 95 216 221 99 55 3 118 53 87 31 5 137 139 170 109 184 111 181 118 5 76 47 98 249 238 105 95 123 219 84 232 34 76 221 145 76 233 236 7 50 83 145 117 99 249 53 49 100 179 115 167 227 214 95 61 120 96 201 105 42 213 236 189 88 186 79 177 192 219 112 90 162 231 7 51 45 247 87 60 112 69 105 172 146 148 47 200 215 240 196 158 151 58 113 167 247 121 46 168 175 143 239 128 85 219 119 78 193 37 121 201 243 40 9 16 26 176 173 146 255 181 21 127 38 161 131 67 195 89 74 49 131 210 169 44 41 61 178 128 252 78 77 207 186 2 180 68 16 72 73 142 59 168 236 28 249 43 47 84 21 115 73 22 28 144 247 37 158 42 238 101 114 33 133 135 185 157 204 254 212 187 203 111 203 44 185 251 45 165 102 213 206 112 117 229 168 226 147 43 164 103 253 2 123 99 203 123 220 173 103 28 28 132 183 100 117 152 80 111 240 165 114 193 118 47 90 61 157 132 134 11 186 230 2 46 69 120 211 0 197 7 33 145 133 68 109 206 244 115 0 220 21 111 255 27 24 6 226 50 43 70 57 11 79 56 214 92 129 36 186 168 175 36 57 174 13 4 83 76 240 213 63 140 167 104 232 197 52 18 84 136 92 206 116 16 160 110)
#f
())
#(23
"length of sequence = 2**32 - 1"
#vu8(49 50 51 52 48 48)
#vu8(213 182 45 175 169 64 197 247 82 69 117 3 169 14 117 105 102 136 240 78 55 35 242 94 229 7 101 247 6 30 68 164 160 45 232 115 149 247 15 15 19 193 99 252 107 69 141 61 246 188 75 168 98 190 18 153 133 143 6 83 115 210 187 181 214 28 142 67 197 34 204 146 172 97 44 109 80 133 147 252 91 221 14 2 84 88 9 70 137 41 138 30 138 205 118 242 204 119 125 134 164 48 196 49 199 177 177 25 198 25 57 154 232 154 120 157 153 160 112 226 171 255 131 185 60 42 121 184 160 102 169 86 16 33 119 27 225 103 119 117 137 97 32 83 179 129 12 18 165 138 233 148 239 86 145 124 250 195 250 219 249 224 197 83 131 1 204 190 181 102 195 115 103 23 227 45 53 142 112 91 228 134 177 154 102 83 61 24 152 252 71 113 232 121 41 252 37 237 110 118 241 108 244 185 232 128 26 104 70 252 193 230 60 112 14 128 154 194 228 52 119 53 161 122 191 154 192 79 106 136 253 18 161 77 54 55 13 175 231 62 99 200 2 185 23 180 116 198 177 191 158 57 160 82 180 25 48 39 196 137 55 87 249 47 110 168 165 187 183 171 212 33 157 86 29 208 183 101 64 136 51 168 78 241 24 213 3 64 103 111 142 16 128 36 34 9 104 65 108 113 55 43 116 197 253 103 129 131 230 50 232 20 242 134 243 41 85 90 25 45 45 13 153 109 71 167 222 110 226 123 166 133 64 173 201 177 49 143 222 182 226 234 195 38 219 100 203 228 236 123 110 11 1 156 81 113 117 118 0 237 223 156 224 10 48 89 30 15 186 47 233 3 126 20 216 219 8 190 83 222 76 137 177 72 73 208 144 34 225 178 233 20 4 93 153 0 200 13 184 175 41 133 193 153 87 198 147 67 12 228 127 20 146 193 223 94 67 191 34 128 10 86 190 5 81 220 172 57 196 147 219 80 252 77 71 16 156 147 176 88 196 135 104 156 65 197 82 62 175 152 232 139 121 39 64 53 60 165 77 173 63 127 176 225 67 184 95 144 73 55 22 250 249 26 67 236 90 100 7 132 226 171 88 197 178 104 238 68 255 255 26 65 181 115 115 178 166 246 5 6 126 19 35 166 137 42 15 15 183 63 66 73)
#f
())
#(24
"length of sequence = 2**32 - 1"
#vu8(49 50 51 52 48 48)
#vu8(122 74 244 84 50 150 155 213 73 178 66 92 254 217 47 38 50 241 42 19 215 63 116 45 186 39 200 134 242 237 72 122 183 175 247 172 255 29 254 187 63 60 86 181 202 128 76 54 4 196 159 195 40 230 128 195 225 73 14 26 190 117 61 230 247 152 183 164 71 45 174 27 125 153 42 239 147 170 23 18 253 43 1 109 222 171 135 85 124 83 9 5 106 173 151 167 122 99 201 102 128 103 86 15 233 153 115 231 133 113 198 14 12 65 249 29 217 182 166 2 156 217 17 250 127 157 97 69 211 76 79 73 164 111 223 9 102 178 153 78 236 55 7 168 79 195 164 115 214 208 39 157 225 232 192 42 80 205 204 154 39 132 170 149 109 118 161 170 17 172 238 231 3 42 25 108 176 59 29 55 68 3 112 7 87 197 83 99 0 5 83 193 142 237 105 163 22 88 199 118 4 121 43 43 156 239 16 29 99 201 161 109 184 141 85 114 190 147 175 142 27 104 56 1 191 5 132 86 221 3 60 18 167 244 5 139 185 229 90 141 49 142 74 240 195 198 45 192 69 182 194 71 200 10 1 132 133 194 125 16 127 111 248 216 59 178 52 249 2 86 128 133 7 154 108 104 4 43 114 69 119 173 24 216 43 71 11 236 115 175 133 93 11 81 204 204 80 95 227 25 155 183 235 211 50 231 54 63 80 116 55 16 164 129 34 64 17 78 235 17 132 162 188 121 163 63 207 105 242 154 97 103 126 225 87 133 211 180 25 243 208 168 47 163 34 114 176 91 133 73 91 241 206 45 46 69 96 170 9 131 163 147 185 75 36 115 80 250 200 86 178 135 153 184 72 34 86 121 87 164 159 202 45 77 166 72 140 114 22 255 241 212 137 95 204 142 98 101 134 67 151 75 140 41 155 176 95 205 70 21 143 146 148 70 165 54 248 86 74 128 110 107 55 179 5 139 36 101 136 31 170 129 87 183 236 131 137 152 254 201 252 37 28 179 54 48 177 197 55 141 57 150 15 56 53 177 10 239 166 17 191 193 173 13 17 247 54 185 229 106 67 77 40 145 186 250 254 139 66 4 150 38 168 163 147 37 179 7 201 146 235 212 111 142 10 42 106 159 0 243 215 225 3 252 24 231 230 230 36 118 7 53)
#f
())
#(25
"length of sequence = 2**40 - 1"
#vu8(49 50 51 52 48 48)
#vu8(89 25 99 194 22 78 46 247 6 207 113 16 81 1 10 155 176 230 243 187 229 30 119 178 17 67 31 183 184 24 135 59 15 75 98 218 88 249 112 170 15 57 125 198 90 185 197 162 205 60 177 205 27 183 177 10 20 213 106 243 120 20 149 93 180 229 186 250 235 94 34 149 111 42 219 139 55 215 219 71 83 65 74 117 81 194 135 214 24 150 123 205 19 140 121 206 42 143 89 6 135 40 92 20 206 255 147 231 172 209 128 5 230 66 33 203 230 113 242 222 161 236 233 86 34 120 147 3 30 43 66 65 167 247 186 212 24 87 155 189 38 25 19 190 144 51 16 42 3 205 193 227 245 9 204 21 151 134 60 122 104 89 33 202 0 80 17 236 89 194 35 130 222 222 53 249 74 204 6 161 150 96 248 18 230 51 215 48 182 206 115 70 133 8 186 247 138 7 42 107 132 40 187 131 246 197 209 29 244 254 20 0 15 176 216 236 177 47 139 244 252 129 28 18 24 210 82 41 48 151 47 187 51 224 191 73 39 245 31 89 33 213 138 228 166 62 215 73 151 97 147 127 72 42 34 173 69 239 190 13 100 230 48 75 232 25 41 106 85 31 149 132 84 239 224 104 91 146 25 49 160 229 116 44 148 184 250 35 239 71 45 11 113 142 249 100 118 242 122 168 122 24 86 32 65 186 18 35 234 52 1 223 16 172 67 180 51 235 184 244 52 219 191 209 205 197 9 149 109 246 28 73 191 98 5 166 27 54 176 223 113 138 225 8 189 65 233 23 36 4 140 139 115 250 189 174 202 229 52 41 171 43 87 199 225 59 174 35 161 72 179 150 57 239 51 30 12 119 221 180 6 139 22 153 220 250 212 60 113 112 228 28 36 70 1 30 88 206 23 34 184 39 108 214 147 101 247 152 224 191 239 175 239 118 110 65 179 208 181 156 138 248 239 143 7 58 198 245 64 162 221 214 161 170 134 40 174 81 0 240 162 217 226 219 158 180 73 227 213 161 199 240 30 124 213 43 195 65 179 140 171 59 38 103 97 3 225 152 0 57 21 105 247 61 137 111 228 68 11 243 233 124 236 48 31 174 66 96 254 203 233 160 204 114 15 91 140 92 209 38 52 86 24 109 119 229 194 5 40 112 219 66)
#f
())
#(26
"length of sequence = 2**40 - 1"
#vu8(49 50 51 52 48 48)
#vu8(142 9 221 235 57 152 171 5 194 228 157 59 24 77 184 109 157 74 25 104 14 56 252 78 225 17 106 180 136 178 213 29 123 193 60 69 175 150 17 170 255 46 43 34 120 67 150 6 206 247 55 54 28 42 68 247 5 244 121 125 164 71 21 74 183 46 221 236 189 246 192 18 5 151 114 137 131 115 106 144 255 176 189 236 87 135 222 85 154 88 177 135 66 33 67 251 225 96 219 193 171 3 204 234 179 173 128 83 129 42 104 233 220 135 223 22 16 187 104 179 223 235 215 236 127 237 120 215 219 164 86 62 91 26 48 187 173 206 104 134 252 239 238 205 63 110 51 20 8 122 49 92 26 219 137 51 98 163 40 49 9 123 9 148 41 239 221 40 21 8 91 120 129 74 115 237 26 153 232 3 247 209 11 82 47 84 10 43 61 2 198 197 174 112 242 159 195 94 193 255 110 200 160 119 155 107 252 249 28 80 157 66 49 24 239 215 217 201 31 208 17 230 120 246 215 173 252 233 5 85 92 6 187 252 75 247 226 245 184 232 186 212 104 188 209 242 179 219 154 52 111 104 6 48 50 197 125 7 21 199 53 44 72 241 23 29 50 148 56 64 245 173 169 20 44 80 242 2 247 103 27 91 74 18 182 181 22 188 204 212 136 193 113 125 196 144 37 244 156 89 135 154 100 148 193 158 46 39 68 92 190 155 178 179 116 58 200 218 190 17 57 70 91 139 129 147 159 158 47 204 144 182 67 43 16 33 163 119 248 206 114 140 43 238 21 109 49 39 22 63 150 190 41 175 26 20 158 105 169 211 131 76 96 231 173 18 6 153 51 225 30 125 108 203 31 54 196 66 255 81 37 11 108 16 80 43 55 7 29 236 231 102 181 237 85 160 104 226 183 50 158 162 155 125 252 143 132 26 124 236 229 49 154 20 116 153 103 180 41 49 226 126 184 50 236 116 155 154 216 179 174 8 2 96 142 170 31 190 66 35 153 52 113 247 45 219 144 112 79 166 69 205 13 154 37 218 21 242 228 215 159 148 157 14 110 173 136 124 48 156 140 222 255 96 197 209 153 15 53 138 185 51 7 125 207 94 108 4 219 67 136 218 30 147 188 51 2 174 107 126 110 251 160 248 211 234 180 215 53 81 54 48)
#f
())
#(27
"length of sequence = 2**64 - 1"
#vu8(49 50 51 52 48 48)
#vu8(77 254 59 212 219 71 131 127 140 73 3 224 219 32 76 45 20 192 151 118 145 246 107 33 176 3 107 184 73 196 104 143 20 114 88 127 199 225 235 103 82 228 26 196 146 251 64 255 20 145 69 101 153 142 195 14 195 217 150 60 36 22 112 2 225 147 74 215 158 159 119 38 34 165 215 78 236 206 129 252 94 60 2 121 7 113 195 228 75 155 163 235 130 243 218 228 73 16 162 165 204 179 180 189 254 5 215 208 120 155 191 121 65 47 194 125 245 11 62 126 215 227 1 108 128 71 5 221 36 224 96 166 11 5 153 113 77 250 70 196 226 41 252 51 128 18 155 158 84 12 191 242 143 211 103 246 240 254 225 63 244 125 210 247 124 4 241 143 241 35 216 240 176 45 200 151 156 155 112 53 171 21 51 168 144 228 155 46 25 166 18 46 152 174 79 176 137 120 175 116 134 227 229 137 203 153 36 205 121 2 106 50 98 40 79 140 143 161 60 143 41 191 178 134 154 60 225 218 166 242 81 63 147 158 30 157 213 194 236 138 140 63 196 127 6 32 179 138 248 191 55 5 156 36 214 254 146 46 193 201 20 26 142 72 4 56 158 50 134 7 255 145 143 187 94 61 232 70 71 158 113 190 85 204 180 121 51 101 185 133 228 162 172 139 120 236 42 64 187 31 9 173 91 240 139 205 111 188 195 252 30 174 141 187 195 246 248 25 231 228 184 245 146 232 226 18 235 161 63 237 49 72 54 49 224 191 234 120 141 232 92 204 203 69 48 126 58 135 63 80 136 163 213 230 120 30 181 34 61 14 73 221 226 55 155 65 59 161 252 224 25 119 52 162 164 241 34 4 177 105 136 213 118 163 210 222 75 143 87 11 203 245 197 224 8 169 105 126 137 237 71 232 55 66 141 65 58 95 170 30 152 167 61 146 218 225 61 169 128 47 97 90 55 65 93 116 224 98 47 48 251 95 99 120 144 178 136 118 218 48 204 168 243 111 99 183 85 168 170 63 159 90 4 144 194 80 37 130 0 147 125 13 131 113 204 159 207 12 248 226 34 6 167 8 111 193 233 51 93 73 98 101 163 255 3 118 248 119 36 247 255 118 63 36 198 60 99 10 141 160 236 77 118 45 165 196 219 87 197 189 75 189)
#f
())
#(28
"length of sequence = 2**64 - 1"
#vu8(49 50 51 52 48 48)
#vu8(66 185 181 61 11 106 16 19 249 154 145 30 97 181 39 253 178 198 23 202 61 249 8 199 76 54 238 90 142 133 106 75 128 59 211 152 35 191 9 62 25 23 18 199 246 198 253 46 8 176 238 121 63 104 30 165 34 5 208 194 141 141 156 192 157 126 180 42 82 39 222 100 102 101 255 172 52 151 24 186 203 117 219 97 159 91 4 233 32 204 180 77 69 214 56 108 214 151 2 65 147 230 143 57 202 43 102 144 111 181 87 94 159 10 185 211 4 98 168 171 109 170 141 162 175 52 3 88 79 175 108 93 144 128 26 89 159 159 106 214 170 142 11 5 249 220 189 93 164 168 22 176 226 191 137 153 155 244 98 243 218 4 124 38 198 35 243 240 12 146 138 21 153 175 212 183 185 2 113 109 129 227 124 130 227 126 133 166 194 226 205 105 69 218 220 211 176 180 171 3 139 45 75 134 67 88 97 93 76 45 19 28 215 52 88 31 69 66 221 156 102 49 136 40 36 123 255 58 90 201 119 191 166 182 226 121 165 240 28 51 159 243 215 122 177 227 95 242 104 240 190 40 106 13 138 97 52 16 190 101 7 144 98 220 247 0 226 98 244 105 41 93 51 146 199 71 34 108 42 105 110 76 27 132 223 244 200 183 113 73 251 158 231 154 95 66 57 82 223 65 97 55 21 192 33 53 76 122 232 143 70 55 213 32 159 91 252 93 144 121 250 87 132 37 230 178 147 65 193 47 119 118 166 182 56 105 0 162 66 47 149 10 207 235 254 71 80 230 15 189 210 111 58 155 232 219 87 148 142 64 211 64 185 255 104 52 176 137 58 111 76 197 218 106 218 212 128 150 52 140 187 167 34 4 33 92 222 177 173 38 247 114 199 191 120 255 27 246 234 202 216 218 137 38 42 106 93 246 158 117 50 248 15 102 82 133 203 147 185 246 154 42 165 6 214 82 235 8 230 242 89 33 19 97 158 50 233 70 61 203 118 210 178 28 194 152 161 48 55 157 192 179 104 89 110 59 3 154 91 173 134 168 139 0 84 34 93 96 138 163 227 186 114 157 63 239 31 185 114 12 158 193 159 236 52 248 0 38 81 237 36 103 118 70 23 176 162 92 54 135 71 133 55 96 195 179 16 150 246 85 56 177)
#f
())
#(29
"incorrect length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(220 232 151 86 122 117 33 156 213 156 2 199 173 239 96 56 245 233 55 174 207 127 26 187 20 22 53 3 231 163 122 149 139 111 216 21 208 136 66 22 16 182 105 196 125 251 150 40 60 78 132 61 214 85 37 152 213 161 11 22 244 182 56 238 151 0 94 19 148 62 254 9 118 79 94 170 41 34 119 153 71 126 78 16 1 13 17 221 9 185 150 77 50 210 192 220 88 18 194 130 194 77 111 163 162 50 47 144 162 125 86 248 215 212 87 178 192 150 95 23 118 138 140 149 193 9 188 115 160 19 12 86 252 28 138 34 117 224 33 100 9 183 157 251 60 131 5 91 19 53 0 111 118 191 46 182 41 214 178 81 45 2 44 22 131 208 239 19 175 0 141 240 219 116 202 225 164 21 87 10 208 190 245 139 191 111 65 236 61 105 239 127 83 240 152 176 76 71 122 8 43 242 122 60 79 145 60 136 245 33 6 24 135 63 141 238 177 46 213 155 117 131 100 221 253 61 27 25 136 47 8 90 152 47 238 165 251 113 89 78 120 166 27 6 0 255 141 70 11 41 175 109 21 82 70 199 125 229 230 88 102 221 96 176 45 228 119 34 168 152 225 148 141 62 127 8 57 104 201 252 158 217 149 35 149 37 175 9 154 81 235 68 251 149 240 253 111 51 4 94 56 17 60 165 232 243 139 127 187 44 179 0 46 232 22 251 136 244 133 92 151 255 201 23 14 86 120 217 105 58 36 109 173 88 226 46 244 162 143 152 226 53 200 14 38 209 213 248 171 208 99 83 88 82 244 193 27 116 184 153 164 133 221 38 44 224 126 192 48 50 23 157 20 34 106 155 60 204 70 188 227 173 216 251 77 240 140 70 120 242 82 229 90 151 37 83 81 68 3 225 128 76 229 241 226 252 226 204 63 210 231 255 114 176 157 10 31 172 138 81 232 180 215 57 25 54 86 125 222 255 61 29 164 90 228 192 34 165 115 24 149 127 42 70 174 141 186 43 18 98 62 141 104 28 252 239 99 130 157 240 10 80 152 54 102 219 244 183 170 91 189 89 117 121 82 15 32 170 250 142 224 247 220 35 131 202 7 23 210 47 179 94 215 92 157 214 85 53 253 254 149 104 76 154 208 118 168 223 169 111 103 181)
#f
())
#(30
"incorrect length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(121 150 50 22 2 208 169 181 170 116 35 147 231 116 202 233 231 71 164 49 93 207 209 112 119 203 222 48 171 241 187 190 248 141 32 143 244 98 207 173 221 9 34 66 246 208 234 190 179 6 56 245 1 87 189 132 75 128 224 47 176 14 191 121 179 214 127 131 83 75 228 240 166 95 36 75 210 27 148 124 55 156 113 205 61 117 232 63 38 221 170 126 100 60 91 160 14 207 123 241 138 139 167 26 93 32 12 83 215 11 235 23 129 228 237 58 20 33 176 165 170 82 51 55 99 186 92 115 146 135 161 216 240 129 66 88 178 146 227 222 52 64 48 250 9 154 240 239 89 134 20 93 161 99 191 122 133 71 55 4 218 168 129 22 179 160 121 203 142 70 133 221 222 252 243 248 203 57 152 114 0 169 75 216 32 18 169 95 91 86 76 185 88 170 239 223 111 14 132 234 200 43 147 0 77 219 244 172 67 67 87 96 81 65 224 208 53 102 237 85 89 108 10 79 94 47 238 108 165 122 168 93 69 76 193 27 63 0 37 33 179 245 156 126 46 205 240 229 95 81 82 98 95 127 130 156 49 114 210 120 215 167 236 47 188 49 172 107 9 217 131 247 59 248 253 132 19 85 93 145 169 155 161 201 93 221 140 97 78 117 149 239 231 17 54 246 157 198 144 63 40 145 75 17 39 230 214 234 244 115 213 104 112 34 26 191 99 151 118 105 210 21 221 118 129 232 185 95 230 207 191 101 146 160 137 230 157 201 119 145 135 251 136 83 111 124 225 95 184 32 1 138 75 5 176 132 58 24 73 12 3 186 97 27 176 127 2 209 21 12 226 213 162 200 123 252 223 131 177 150 86 67 121 65 59 137 153 18 186 202 151 225 209 156 90 247 222 177 235 57 145 202 39 51 96 73 149 162 232 200 1 161 216 19 180 166 85 105 35 139 150 22 85 225 145 67 97 11 254 218 48 240 166 192 82 103 116 166 34 161 91 246 217 29 95 247 163 189 135 173 129 168 92 32 24 62 158 114 144 212 159 10 92 46 8 4 83 144 106 95 30 103 149 45 110 14 80 151 197 135 32 81 156 197 184 181 43 196 246 58 169 189 170 214 216 5 47 201 229 61 103 13 241 145 216 156 93 188 45 115 89 241)
#f
())
#(31
"indefinite length without termination"
#vu8(49 50 51 52 48 48)
#vu8(120 146 241 45 219 212 141 32 171 160 128 243 183 201 44 181 201 24 196 22 162 247 25 153 200 158 121 14 146 128 41 104 246 131 96 41 41 248 195 122 202 242 224 167 51 126 133 181 240 188 185 226 233 161 32 137 33 213 120 178 78 173 243 188 142 19 5 113 100 141 173 193 68 224 127 109 236 255 79 254 24 169 68 184 254 179 132 116 217 223 8 219 40 182 94 193 85 209 104 243 115 113 112 138 241 56 49 107 231 1 3 232 244 168 179 114 172 13 58 157 222 179 20 77 176 81 32 137 159 135 89 163 124 204 147 208 192 144 124 131 228 1 240 243 17 138 118 221 178 239 20 198 42 48 79 97 131 24 226 251 238 29 84 89 228 132 55 237 69 245 197 239 205 138 133 228 32 211 80 243 194 77 203 95 15 235 20 145 1 148 56 228 216 244 147 23 243 236 103 14 237 174 13 34 250 107 231 15 241 144 5 123 215 201 223 100 17 226 174 124 192 243 91 236 16 102 188 35 215 242 190 144 183 121 224 23 243 185 73 155 50 206 18 84 122 152 203 80 64 54 32 234 174 195 55 87 191 173 32 197 92 104 15 200 229 176 169 216 217 149 139 31 195 119 253 52 115 147 105 203 145 24 184 237 64 219 41 134 73 117 244 69 26 188 47 12 149 19 186 29 104 33 206 101 192 90 79 125 10 247 254 185 38 124 92 137 10 255 119 155 57 230 120 44 57 24 82 30 212 165 31 240 73 184 254 158 93 143 92 217 239 217 227 179 125 195 160 198 23 105 254 37 163 231 84 2 18 19 41 174 80 119 182 231 31 57 237 50 214 198 195 194 107 218 76 253 167 87 188 66 229 218 28 159 106 153 53 159 195 179 193 91 174 55 82 143 29 243 116 52 125 223 70 132 165 172 172 220 141 228 170 93 114 115 205 145 226 158 132 199 94 25 126 161 104 0 75 237 128 56 173 91 66 52 62 136 203 221 7 59 174 179 177 251 124 141 241 85 251 115 177 247 34 244 69 77 100 159 147 157 173 43 126 201 59 48 156 193 14 238 230 99 75 249 107 99 170 20 67 78 150 221 113 74 114 255 226 213 129 186 211 123 160 199 61 174 29 210 62 230 214 116 63 69 114 50 206 179 9 178 88 96)
#f
())
#(32
"indefinite length without termination"
#vu8(49 50 51 52 48 48)
#vu8(192 169 78 209 201 181 81 33 150 13 200 209 40 212 221 98 117 61 81 152 18 13 180 52 81 80 66 135 9 124 116 109 116 182 190 53 202 182 219 16 60 26 232 129 137 217 30 194 2 139 113 176 94 225 54 30 255 65 179 235 25 28 8 72 139 188 221 232 136 249 29 41 111 254 104 181 168 129 97 26 16 77 183 123 141 63 125 236 147 46 84 46 234 20 222 107 9 70 203 132 80 69 94 64 98 60 201 134 155 146 20 43 234 190 59 241 229 10 99 18 222 162 100 64 46 7 156 91 183 142 47 1 220 236 239 190 25 149 138 19 7 132 146 83 86 0 251 5 40 96 246 115 196 4 97 120 167 241 79 79 49 111 71 107 89 84 71 174 106 205 42 176 152 246 201 164 104 181 144 154 143 247 88 250 237 111 69 120 49 88 62 82 190 101 119 172 105 63 59 81 152 72 136 211 151 126 95 29 112 244 110 73 231 45 12 244 108 223 169 144 71 169 182 132 162 49 124 155 69 207 212 80 231 164 112 209 71 103 122 192 223 188 100 71 182 209 221 40 142 165 118 155 122 109 109 56 181 54 217 82 210 86 161 245 5 93 5 142 181 215 216 218 51 195 94 42 249 40 20 56 74 182 114 65 66 44 33 36 179 12 130 137 254 124 80 110 249 96 246 253 101 36 139 128 99 128 96 66 29 31 39 77 18 181 83 122 43 153 3 14 170 5 87 29 174 50 133 127 218 230 72 42 108 152 158 152 122 168 116 162 206 82 134 209 111 234 5 202 9 156 206 73 83 142 232 46 43 211 153 26 201 174 243 124 189 159 84 152 232 108 116 42 191 230 119 138 171 167 81 74 216 38 163 245 55 114 233 231 64 223 95 168 195 232 248 142 131 111 63 116 247 67 2 61 195 26 73 137 124 98 54 179 113 1 39 154 167 127 96 93 111 59 11 75 74 218 125 33 22 239 149 236 46 163 217 49 21 17 47 69 66 165 209 48 157 247 135 167 130 149 160 178 87 47 220 179 240 225 239 246 197 53 55 72 142 247 98 45 152 13 154 138 46 51 169 214 146 50 219 160 10 100 150 218 28 238 207 5 91 120 241 150 211 246 124 128 204 105 49 251 124 131 147 77 29 68 163 116 156 177 158 119)
#f
())
#(33
"indefinite length without termination"
#vu8(49 50 51 52 48 48)
#vu8(196 107 110 124 73 99 207 125 155 64 213 128 82 213 154 16 211 164 99 109 199 17 100 21 128 153 227 211 7 27 125 196 199 6 191 59 45 135 99 206 127 49 231 130 144 146 170 116 210 184 0 192 39 78 77 143 32 61 51 149 58 75 122 86 36 173 139 135 66 162 131 92 3 11 219 2 42 150 53 79 147 11 138 182 96 142 140 131 200 137 172 93 246 194 120 35 224 5 12 60 234 217 45 181 243 217 98 77 123 74 249 21 228 33 91 210 92 194 227 19 143 250 7 2 30 84 96 160 54 246 194 73 202 132 46 138 231 4 167 194 82 199 222 34 145 206 16 30 162 134 101 238 67 110 128 181 103 143 200 75 241 44 75 200 31 53 216 19 250 200 231 29 187 171 3 32 192 153 113 112 176 126 95 6 66 110 102 173 126 9 175 238 134 193 114 36 103 20 85 207 232 147 194 150 107 31 228 255 11 163 219 30 76 207 84 21 103 215 150 110 41 177 50 41 13 164 112 94 151 105 231 110 123 228 217 202 221 202 93 44 26 173 61 15 248 127 188 19 100 104 224 163 37 131 148 155 146 163 149 211 109 133 96 2 241 108 37 22 147 241 71 222 225 219 249 15 5 131 139 37 170 67 113 44 45 133 218 217 98 54 41 118 66 62 223 17 99 28 64 153 180 181 196 66 29 150 134 72 7 101 200 126 11 176 70 178 80 45 200 90 113 175 108 245 38 78 121 89 213 190 182 231 151 222 24 195 250 188 121 221 77 91 94 109 143 93 189 133 36 99 183 171 228 156 134 2 238 225 43 139 13 74 123 195 41 114 44 121 213 117 4 35 159 51 29 39 166 46 99 173 26 144 80 210 220 57 64 186 221 169 197 86 49 218 181 173 43 201 230 187 188 141 146 2 116 213 72 121 34 9 137 235 182 213 219 94 214 189 47 163 110 21 16 167 106 23 68 125 123 29 141 46 151 135 195 169 142 150 132 98 33 82 235 79 101 192 76 239 85 103 5 86 215 71 219 32 58 166 37 98 144 61 95 34 147 206 56 194 146 10 251 65 160 205 148 200 124 213 199 91 168 76 213 180 173 132 28 151 243 36 137 86 42 133 113 203 40 43 144 71 217 62 242 133 252 184 103 190 60 247 168 120)
#f
())
#(34
"indefinite length without termination"
#vu8(49 50 51 52 48 48)
#vu8(72 130 24 50 54 15 76 143 198 165 189 3 108 88 227 96 116 224 64 76 186 179 237 245 247 142 154 154 147 155 115 43 219 229 144 157 9 208 132 252 71 222 27 110 167 189 30 232 45 69 22 127 164 153 52 250 23 254 41 134 191 213 64 185 84 153 14 141 176 81 56 114 132 77 160 176 177 170 180 231 202 172 28 203 230 202 26 88 210 54 78 176 250 82 102 64 130 233 45 126 5 233 251 149 176 242 127 26 140 18 2 253 77 90 27 151 235 97 244 252 128 175 231 44 56 229 121 47 51 118 195 42 1 219 122 222 103 4 114 92 54 151 198 94 71 0 228 180 201 64 23 210 193 105 96 59 101 56 135 146 222 43 163 138 246 199 88 191 100 86 214 24 119 234 58 248 54 78 134 52 98 30 31 216 22 124 106 243 37 90 68 220 86 228 145 93 78 226 250 119 176 225 211 205 195 225 160 178 3 128 149 166 70 43 7 197 95 218 245 247 88 98 214 157 190 199 219 141 110 99 178 223 125 153 248 180 169 128 147 253 205 238 182 128 189 22 49 248 159 215 252 102 123 47 127 167 13 55 148 237 215 220 112 211 132 143 203 244 125 41 19 47 195 68 213 43 5 142 153 217 20 108 205 176 250 22 184 26 187 31 17 68 101 158 183 155 192 211 205 193 89 223 190 100 101 141 120 192 165 145 245 15 136 253 238 251 251 137 113 109 12 139 122 233 131 207 0 204 14 184 193 78 193 143 95 115 23 57 61 251 239 216 23 116 248 145 113 188 27 70 230 235 10 159 87 92 141 49 179 105 65 132 248 241 33 24 143 16 86 3 36 166 124 117 92 207 129 102 50 209 67 103 150 97 192 190 98 134 155 32 200 185 157 117 34 85 182 123 248 211 247 129 133 89 33 133 82 211 66 103 232 47 128 92 10 99 129 231 184 47 168 98 177 175 129 249 110 127 222 61 89 209 177 248 131 130 33 49 243 90 58 127 134 7 164 146 6 109 73 88 164 106 51 150 64 83 63 67 25 81 200 70 98 96 72 150 240 75 224 7 87 139 143 160 190 150 174 97 148 111 244 211 133 60 2 30 238 41 84 26 186 104 240 140 142 195 33 70 5 135 69 239 20 252 31 190 249 59 246 1 175 193)
#f
())
#(35
"indefinite length without termination"
#vu8(49 50 51 52 48 48)
#vu8(19 14 204 246 98 117 208 81 140 191 22 123 111 146 37 37 222 54 242 29 157 154 215 68 131 163 74 204 101 218 153 109 26 152 130 94 27 57 40 20 21 232 114 69 51 181 221 250 202 204 122 254 255 26 162 142 28 250 141 7 148 131 211 93 235 228 255 189 217 207 207 6 234 36 66 102 206 116 68 173 145 230 111 203 29 79 231 186 185 61 41 230 151 38 246 254 69 223 26 166 132 48 78 22 12 45 176 27 57 98 139 74 105 161 202 72 48 86 40 211 229 168 45 120 144 160 188 68 53 79 59 100 4 115 200 216 248 42 49 62 190 134 176 121 53 169 78 108 164 202 6 23 2 39 152 76 226 248 210 10 252 152 88 36 96 72 185 107 164 215 182 47 114 71 186 193 124 141 19 0 70 254 80 231 171 172 126 138 206 226 224 44 246 141 111 136 83 172 88 82 39 81 133 62 137 235 54 71 13 130 85 244 57 36 19 134 64 215 86 109 13 45 102 208 125 73 210 5 109 59 9 188 164 151 236 136 44 107 96 16 130 159 136 255 72 187 82 109 114 21 188 197 97 60 91 137 212 203 18 205 157 65 118 30 22 117 107 113 100 178 55 205 223 9 55 121 123 255 96 32 165 21 139 195 54 74 251 99 77 12 41 45 240 104 237 41 245 227 80 28 26 166 150 21 102 198 29 38 65 189 63 144 18 194 227 227 70 83 117 2 197 6 136 172 227 121 21 89 16 217 129 4 32 95 27 222 215 69 244 15 251 118 106 69 221 144 208 133 237 163 132 251 63 17 33 0 173 39 244 55 229 108 191 78 71 24 10 226 214 66 65 114 102 76 17 19 105 134 237 83 229 174 254 240 123 146 123 92 70 190 140 88 73 132 52 114 191 7 230 196 159 47 104 235 109 97 148 96 191 24 63 66 78 56 59 92 133 142 54 194 242 135 245 192 52 201 230 14 249 169 46 216 97 171 186 156 5 114 39 253 242 218 206 238 192 79 175 22 128 117 18 133 97 92 240 55 52 168 176 122 173 216 31 87 98 119 106 35 82 88 173 89 98 175 45 184 194 6 85 46 159 247 125 175 228 87 87 46 70 74 13 195 36 213 151 243 93 137 224 206 251 141 1 146 167 73 200 171 136 86 117 77)
#f
())
#(36
"removing sequence"
#vu8(49 50 51 52 48 48)
#vu8(74 255 254 80 209 23 61 37 187 192 242 180 48 88 153 37 225 204 133 165 55 11 50 179 221 76 240 81 250 128 24 85 82 206 69 113 70 55 39 146 171 233 35 139 235 246 114 126 141 160 108 101 46 202 231 93 26 51 178 84 169 68 11 84 205 192 194 241 250 95 130 253 164 130 110 208 224 191 35 6 144 164 81 241 78 28 159 234 57 57 161 65 211 84 226 36 10 125 73 213 125 64 85 106 132 234 11 30 39 241 145 79 122 207 103 134 92 104 229 47 64 98 40 160 190 157 86 25 219 189 11 9 9 40 235 253 135 163 87 212 50 24 160 214 63 181 232 124 216 95 70 115 176 207 164 93 87 142 96 132 118 214 230 231 251 99 35 153 229 172 123 182 90 238 27 196 62 134 145 157 95 40 58 195 10 209 178 27 255 25 197 23 107 36 163 197 153 31 9 141 236 193 34 195 94 47 128 155 106 251 249 18 131 149 209 38 53 14 42 158 245 1 48 6 76 116 227 14 52 186 151 211 49 146 6 154 40 98 20 228 215 35 225 70 74 30 235 128 77 104 220 84 8 37 47 28 66 11 152 174 17 143 181 14 41 11 145 154 187 188 55 154 165 161 162 206 200 137 130 254 236 96 41 167 1 142 43 99 83 183 255 89 97 221 110 68 220 114 202 151 49 136 6 226 77 222 70 220 15 20 52 197 6 224 112 227 27 118 244 183 49 102 17 65 96 64 71 233 48 24 206 122 44 191 60 56 184 35 74 48 73 141 129 208 18 15 167 14 173 248 144 206 209 85 173 93 72 106 164 241 121 11 245 155 217 115 28 238 104 107 93 77 17 91 220 18 69 7 157 239 169 9 46 131 154 181 103 166 231 65 200 118 15 52 47 240 240 4 214 247 29 174 70 61 4 5 59 152 213 1 148 7 240 168 133 119 143 124 56 209 246 254 128 183 67 53 79 209 212 197 247 35 72 33 164 31 111 238 101 133 0 36 39 99 227 57 166 234 54 45 177 233 205 188 113 119 115 63 23 51 26 189 151 172 74 20 140 142 44 109 199 230 119 104 83 211 115 8 243 163 252 26 95 39 36 237 30 103 147 101 29 167 182 254 158 142 129 152 229 141 143 129 55 163 110 197 39 86 34 241 1 138)
#f
())
#(37
"removing sequence"
#vu8(49 50 51 52 48 48)
#vu8(217 12 195 176 28 218 146 48 87 86 46 177 28 1 62 195 207 119 218 108 50 86 85 168 150 94 180 38 250 211 71 134 185 180 124 56 73 144 97 53 212 167 233 17 108 225 170 61 189 72 147 69 104 111 183 152 57 71 192 58 232 42 208 111 170 68 201 91 125 248 168 186 212 98 138 149 184 22 79 117 245 159 33 174 38 172 112 163 198 0 9 168 215 251 199 245 150 80 217 111 25 35 47 140 16 27 163 237 17 39 232 159 47 141 16 196 168 85 11 14 229 161 99 179 150 140 158 37 47 19 168 53 250 221 176 144 211 87 56 106 150 160 53 74 184 75 17 157 142 238 205 151 49 41 237 173 230 69 10 149 243 184 189 78 227 47 32 238 250 84 39 92 95 82 43 189 230 144 102 100 213 230 18 193 91 91 125 85 190 177 163 104 128 188 238 176 236 99 230 44 143 0 122 131 111 40 117 146 71 246 6 247 192 58 201 52 209 40 95 216 136 101 64 5 74 200 33 47 159 181 92 1 178 170 125 55 38 196 222 15 185 223 78 179 232 131 252 71 158 81 100 6 2 176 211 6 193 23 240 252 72 215 30 251 205 184 152 162 181 83 179 147 51 211 24 147 172 157 127 194 186 19 244 51 75 171 164 249 244 20 122 160 114 145 44 49 127 34 159 4 87 30 86 247 113 135 59 237 186 248 199 100 18 19 176 101 9 225 211 142 81 145 87 56 66 105 11 209 125 61 22 250 160 228 38 60 211 87 106 232 226 93 162 0 55 228 112 26 254 187 176 227 197 186 139 175 46 186 145 199 166 54 1 87 116 6 247 254 173 17 157 76 63 10 33 111 79 218 127 166 184 105 237 175 242 104 59 82 18 44 198 14 222 181 181 83 108 133 131 195 157 247 209 224 198 31 122 94 225 156 231 200 121 68 2 88 166 176 116 131 33 14 59 80 130 125 17 141 3 134 203 81 28 239 245 154 254 109 105 20 222 132 215 165 237 68 114 136 224 70 68 2 100 219 180 141 201 36 146 38 201 39 134 181 33 15 234 194 49 142 45 185 22 97 217 101 66 166 25 46 63 205 190 246 121 190 51 168 191 248 211 30 102 234 65 205 174 101 208 170 24 195 196 96 206 151 49 177 77 150 122 190)
#f
())
#(38
"lonely sequence tag"
#vu8(49 50 51 52 48 48)
#vu8(123 106 126 135 43 24 69 243 33 129 74 247 178 15 169 135 155 162 142 30 20 51 183 24 166 254 14 82 31 200 114 94 87 228 171 12 222 29 83 176 219 237 197 160 202 207 6 35 123 46 183 149 232 155 141 47 189 10 162 39 17 173 48 132 155 113 253 87 214 127 110 182 162 168 137 61 142 214 133 82 193 99 129 23 34 180 5 51 0 64 145 122 255 190 42 116 107 77 19 66 129 152 17 26 195 228 214 51 104 234 46 226 227 219 10 34 250 4 85 45 132 122 14 217 180 62 250 61 189 11 113 226 151 196 186 249 227 15 148 176 107 63 30 192 85 55 19 70 10 247 124 252 113 229 55 234 31 121 74 236 177 16 91 87 98 0 66 231 91 36 129 137 54 76 39 152 15 14 75 56 47 197 76 180 183 178 2 142 231 61 4 170 252 113 231 126 25 231 81 177 16 107 58 251 255 128 135 109 164 51 225 62 70 7 168 75 212 226 222 133 204 207 169 67 55 216 24 210 16 13 138 179 129 143 122 151 61 113 100 131 30 158 33 241 201 81 12 206 187 77 76 223 233 50 18 117 126 249 123 64 185 71 161 13 200 70 254 94 125 93 79 73 42 203 50 132 163 24 161 28 18 170 156 40 40 1 61 8 198 143 133 77 10 217 39 138 225 232 139 168 214 132 159 255 2 97 38 192 79 77 214 51 230 211 90 116 88 92 180 202 184 120 72 57 31 211 252 199 116 18 103 110 165 200 95 202 117 213 36 124 40 58 177 104 180 129 115 183 117 59 205 108 32 96 118 69 251 81 226 31 67 173 28 245 193 150 140 115 228 218 7 147 62 198 136 41 213 105 197 204 39 12 175 204 131 1 95 203 106 228 142 107 164 180 84 42 200 2 243 152 66 141 150 158 27 43 165 38 30 157 126 206 192 245 89 181 74 107 241 177 39 39 220 100 12 141 199 13 113 242 135 98 39 245 241 178 184 187 6 142 148 20 14 177 237 221 253 76 236 84 233 185 62 13 96 239 45 54 207 79 186 6 154 114 89 154 127 133 111 155 18 222 119 206 182 88 234 122 182 21 255 54 6 128 72 5 222 25 99 9 1 94 77 79 60 115 224 145 232 254 36 217 244 157 15 113 7 188 113 158 129 110)
#f
())
#(39
"lonely sequence tag"
#vu8(49 50 51 52 48 48)
#vu8(90 107 177 181 22 210 64 108 187 57 141 234 250 147 133 139 249 244 227 208 34 155 241 179 107 175 117 52 38 91 83 174 197 192 57 195 113 209 253 214 175 46 226 165 214 226 175 36 68 21 253 99 4 67 206 168 186 77 121 111 72 33 46 227 252 165 129 87 18 190 114 174 106 104 243 107 81 36 187 13 87 33 250 4 218 68 227 164 159 2 209 74 70 131 64 0 14 3 148 168 242 199 172 120 128 28 222 56 125 218 109 223 205 101 63 165 5 52 226 4 205 68 198 121 190 102 242 174 228 153 254 205 99 148 108 91 72 133 186 165 151 186 22 206 44 254 154 243 130 135 157 104 255 6 19 159 181 231 209 234 104 186 91 244 243 87 10 25 18 251 168 157 109 197 39 27 88 142 22 132 200 240 185 242 14 124 178 73 22 232 123 225 196 96 13 46 67 75 34 217 36 38 12 27 147 77 99 13 243 173 182 75 121 102 41 37 176 154 200 198 111 142 116 164 152 104 248 167 255 35 40 15 90 77 117 201 113 30 89 205 178 75 48 33 192 46 61 201 147 22 30 204 59 63 222 191 72 88 27 41 132 232 124 237 35 140 199 151 232 161 115 237 13 241 185 168 70 27 181 99 72 242 114 164 59 44 138 6 91 131 255 159 216 14 120 171 122 166 239 239 230 3 163 198 247 209 85 140 78 94 235 58 137 103 50 80 169 225 90 50 87 171 202 48 151 116 114 136 19 235 171 42 224 244 212 204 77 112 51 16 168 223 104 251 126 15 191 88 220 40 12 19 156 220 20 190 151 205 155 221 140 250 44 191 20 206 124 249 79 145 145 177 7 121 9 136 42 228 161 129 176 220 232 171 166 156 105 190 183 82 200 12 127 161 144 37 227 211 144 129 8 67 27 16 226 112 205 199 172 117 171 4 10 143 5 34 232 144 241 169 91 108 23 70 185 239 34 0 64 8 33 220 77 133 206 158 253 219 213 27 21 128 55 123 54 50 106 198 176 216 142 10 114 99 195 129 86 5 165 23 206 229 203 137 187 17 143 199 131 173 62 213 103 0 172 130 65 34 85 70 156 56 198 53 43 53 74 14 141 122 13 10 62 187 152 121 28 24 174 233 153 98 192 211 254 227 212 145 128 18 143 26)
#f
())
#(40
"appending 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(166 245 8 183 87 247 162 41 154 15 37 158 2 91 83 234 173 183 44 176 19 41 131 250 201 85 205 238 23 6 187 19 33 70 54 52 247 7 204 173 248 2 145 164 86 99 193 103 107 126 122 36 253 122 25 93 58 232 177 243 170 66 236 85 181 191 129 2 193 105 26 159 111 235 77 100 98 230 98 25 169 170 26 156 133 195 58 62 209 35 166 197 99 222 97 80 39 190 207 39 34 191 176 11 148 39 166 65 182 172 202 146 156 175 34 1 99 6 54 240 0 226 82 36 109 151 157 2 124 86 109 229 129 92 25 160 110 223 186 22 60 240 247 142 42 115 185 38 237 89 225 135 72 72 217 26 3 229 121 40 156 217 220 218 232 82 207 198 29 184 254 1 83 206 150 102 9 204 207 172 21 17 87 100 58 186 22 119 116 158 20 10 129 197 212 136 62 104 216 165 130 199 81 156 154 15 211 96 11 31 129 58 254 6 179 245 3 154 198 8 245 177 137 188 28 91 15 194 253 43 61 145 233 54 41 139 49 43 205 166 85 74 81 205 169 122 169 242 47 113 24 245 101 1 127 86 144 253 80 10 185 1 118 202 194 12 2 81 197 248 45 105 28 6 149 202 53 199 165 80 227 221 163 162 12 126 29 52 135 13 4 160 30 158 205 159 3 145 20 48 33 161 50 140 116 190 223 131 148 83 13 88 104 224 254 161 119 192 32 116 225 215 50 250 233 158 94 246 125 230 20 117 56 137 208 12 17 172 192 123 190 97 197 8 22 89 226 217 153 79 129 177 81 0 152 167 242 213 154 115 86 156 104 156 24 129 224 55 14 0 235 152 38 204 149 183 69 105 167 188 172 206 70 119 1 225 20 36 245 216 0 185 16 96 108 69 60 126 144 141 131 87 240 51 59 130 155 16 210 98 24 50 181 6 124 239 7 128 200 239 154 54 159 243 37 105 237 46 162 5 78 209 226 95 42 250 243 75 17 13 236 100 133 51 240 207 180 174 142 243 39 216 52 26 192 84 80 22 85 35 91 125 208 232 174 168 201 61 214 86 210 137 226 75 200 14 144 190 196 114 232 118 160 241 213 8 192 159 28 132 68 190 110 16 48 132 142 214 168 145 191 219 151 103 125 48 184 245 245 254 42 166)
#f
())
#(41
"appending 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(226 110 72 218 206 155 57 187 116 115 92 153 21 44 187 103 3 70 135 68 245 44 68 178 27 230 227 226 249 99 56 66 239 1 174 156 56 151 75 74 236 56 137 15 124 211 189 134 90 121 30 180 117 83 185 57 199 25 121 241 111 227 185 214 12 104 84 88 57 182 8 155 204 251 236 193 106 188 43 154 191 237 228 97 141 105 19 236 44 215 132 141 205 61 253 76 133 221 188 234 223 210 39 121 151 226 82 57 246 106 50 113 3 105 18 213 151 67 40 212 57 184 147 90 16 248 75 4 226 157 197 110 143 108 216 81 165 44 105 214 88 195 105 162 181 206 228 101 185 151 195 19 32 243 217 248 213 120 162 93 40 164 60 243 131 6 78 234 2 39 128 162 143 74 217 240 150 43 19 82 186 68 26 202 131 97 137 210 176 26 195 9 74 104 193 140 180 158 222 161 221 52 138 163 35 116 229 213 202 50 145 132 208 19 154 214 74 67 62 136 153 212 26 68 139 171 103 240 53 4 96 243 188 8 30 50 177 139 226 86 67 99 79 63 87 105 232 200 199 149 137 234 73 164 113 239 146 57 8 106 129 77 77 139 207 83 241 185 201 243 39 48 93 13 78 88 121 187 119 2 207 53 29 49 228 54 136 140 99 173 100 234 83 137 76 92 38 13 199 188 186 47 193 56 192 27 147 32 101 106 92 201 233 250 186 208 204 15 30 104 96 158 221 81 83 139 171 203 72 85 233 13 235 224 229 112 119 134 12 77 49 8 145 64 90 171 149 197 28 135 212 141 46 242 118 225 237 186 54 4 137 53 241 136 59 105 230 176 158 132 235 202 114 126 99 146 217 77 35 37 255 148 62 45 131 128 1 39 41 10 106 239 85 194 240 79 170 134 44 23 68 137 82 199 161 142 109 73 152 209 40 69 159 221 210 74 168 41 133 97 232 175 9 217 79 122 197 141 181 9 211 118 19 44 17 51 87 10 33 22 4 112 26 82 194 51 137 111 32 120 59 134 213 129 71 77 173 113 174 178 165 96 211 37 213 94 116 171 225 116 50 20 63 123 174 88 215 148 139 44 116 57 16 254 53 87 115 29 117 72 111 56 189 201 66 221 26 238 210 22 71 110 190 158 59 136 51 239 43 169 123 207)
#f
())
#(42
"prepending 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(62 17 72 250 155 235 243 126 135 90 81 197 45 197 9 160 132 151 182 173 251 218 26 99 86 95 182 60 15 45 246 244 99 190 144 205 190 188 165 135 17 75 241 171 50 207 53 22 4 157 60 101 48 206 141 199 183 223 198 168 196 166 221 168 34 27 191 111 221 220 137 101 130 10 54 206 179 63 185 143 55 176 73 12 170 42 158 92 58 26 240 17 61 146 234 156 109 240 234 37 111 252 191 151 219 172 99 22 198 181 252 25 105 181 163 195 144 252 253 186 55 11 77 128 43 44 62 83 217 221 189 219 200 136 190 199 56 67 34 253 245 80 82 62 20 146 50 100 52 183 126 38 250 81 226 19 196 150 6 2 14 53 71 254 16 183 148 159 110 115 75 180 172 230 93 31 196 91 74 152 182 67 205 9 23 170 233 49 88 51 252 113 20 161 84 136 43 186 172 153 154 134 233 202 30 31 41 255 46 77 59 244 74 169 27 238 126 225 134 71 163 255 158 3 61 242 138 157 52 225 243 238 164 12 88 72 163 156 41 189 139 54 252 240 38 74 88 238 101 134 203 62 53 30 174 34 132 142 21 164 130 233 40 133 130 193 80 90 145 112 100 219 34 144 155 129 234 55 24 255 102 194 85 27 240 187 114 210 16 174 44 53 104 183 31 166 84 153 63 117 98 10 30 65 79 218 62 186 22 64 106 106 116 19 119 82 224 218 31 158 38 77 245 160 37 128 117 71 199 35 100 104 47 220 202 121 220 4 15 208 19 180 180 237 63 131 245 178 215 41 100 15 57 58 71 186 11 78 202 196 86 146 238 114 69 128 146 70 185 240 16 137 109 163 85 244 7 138 224 120 138 0 125 127 173 165 139 146 84 224 181 234 190 78 71 73 104 76 72 27 148 10 88 160 13 183 212 229 41 111 74 95 203 248 169 200 247 186 81 113 42 198 79 179 245 31 237 155 134 110 134 197 53 75 41 119 150 230 109 84 243 173 164 57 72 181 192 96 91 52 204 211 159 124 57 17 46 165 77 149 28 136 177 102 197 215 25 0 112 228 2 44 242 50 22 18 17 220 19 102 143 55 240 182 22 2 229 26 173 219 250 156 146 244 58 228 46 5 125 137 217 76 65 176 233 62 39 253 141 200 32 42)
#f
())
#(43
"prepending 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(185 159 230 247 227 215 166 34 188 98 140 96 241 168 119 35 9 194 174 116 233 6 170 126 13 124 51 47 153 22 41 133 158 223 147 79 122 56 214 90 88 106 100 100 98 255 245 63 183 100 199 235 157 116 165 153 199 86 24 52 199 237 187 24 108 149 52 29 127 40 50 35 69 55 216 199 209 109 55 34 218 141 224 196 204 189 127 104 250 65 224 205 2 89 236 60 215 15 37 153 57 49 105 13 70 115 81 182 214 232 158 181 158 54 238 154 44 135 27 112 72 0 148 31 45 252 168 14 78 244 107 189 170 187 227 171 116 221 170 65 59 109 139 10 145 34 17 46 146 95 25 62 3 53 7 31 217 251 184 4 134 203 41 104 49 128 166 114 191 239 158 34 189 153 45 70 249 150 181 222 84 189 248 179 119 34 130 220 154 223 227 176 91 147 101 53 146 35 207 38 115 183 1 207 104 27 249 125 154 234 143 20 37 203 184 187 4 116 219 84 112 36 34 11 53 146 41 76 44 8 153 128 97 171 95 120 142 201 193 182 249 36 94 98 27 198 133 96 68 99 6 214 87 150 152 53 1 50 168 157 198 80 247 123 51 76 45 114 13 84 55 177 228 85 98 125 39 38 216 138 166 131 185 58 23 252 136 132 208 72 29 0 118 92 119 8 16 83 33 213 127 24 214 76 130 104 5 140 148 120 122 206 207 105 61 168 199 205 226 4 254 172 9 147 175 5 63 90 145 231 142 190 224 112 114 164 99 142 178 122 102 14 237 41 196 180 24 54 57 197 27 112 14 177 30 115 22 117 4 38 218 116 201 190 165 69 5 25 89 177 34 117 59 233 199 9 237 231 109 94 11 188 33 66 127 149 248 236 220 170 215 233 7 109 18 48 179 99 164 146 189 22 36 65 254 34 33 2 128 152 33 56 187 30 154 218 135 30 215 25 183 249 247 163 110 79 246 154 46 194 192 125 122 219 66 29 236 97 134 78 96 134 19 187 197 57 193 102 107 221 108 45 175 242 28 23 13 105 47 233 35 101 31 42 238 40 168 138 151 179 238 14 112 125 171 80 51 55 113 108 241 196 71 251 209 129 247 27 181 33 193 203 16 255 44 100 210 63 29 100 200 225 204 140 11 150 56 57 221 28 194 238)
#f
())
#(44
"appending unused 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(217 144 127 112 26 158 86 150 173 215 63 247 5 93 98 173 226 123 194 249 69 50 122 162 15 46 54 203 158 103 102 98 147 234 229 17 225 29 183 222 22 2 73 63 50 26 142 178 149 171 152 8 193 235 45 11 16 234 247 128 2 189 214 167 230 92 45 39 146 128 176 55 79 238 164 185 236 23 114 237 213 123 61 11 238 108 44 67 169 246 237 185 198 205 76 241 87 129 234 133 158 238 134 225 163 84 194 119 84 153 96 224 93 173 96 184 51 72 244 58 42 140 22 250 39 53 232 86 42 129 27 218 26 195 24 16 44 47 52 159 218 56 39 182 23 105 24 187 141 25 175 241 149 217 167 241 93 51 151 191 196 55 134 155 50 44 173 216 88 41 69 221 170 78 224 116 22 20 182 46 226 211 34 1 91 50 218 42 230 243 191 180 164 188 99 104 14 171 220 142 205 220 250 19 213 105 50 7 63 127 150 170 89 68 131 26 11 238 117 223 186 85 62 107 250 232 204 103 202 137 49 22 172 248 231 169 146 14 174 57 63 188 64 235 52 18 12 225 53 101 157 149 174 40 90 160 15 138 119 67 26 154 143 131 228 143 8 64 188 159 223 137 17 48 191 113 226 220 175 9 11 106 135 212 39 129 105 49 197 167 124 160 75 132 49 196 201 110 155 146 64 221 27 137 51 86 83 222 132 97 82 8 185 152 12 227 53 136 200 161 69 179 115 244 218 224 191 28 114 42 144 244 162 25 57 249 212 0 244 173 206 227 151 163 251 73 191 189 60 116 89 54 152 84 0 235 145 37 18 108 92 77 118 222 219 117 193 27 28 42 67 136 212 94 29 206 172 93 70 122 142 237 92 239 221 188 102 62 243 200 216 83 171 30 9 2 46 137 33 139 4 39 82 149 94 191 173 20 71 188 17 62 33 192 171 227 47 255 84 188 178 182 141 143 24 247 167 24 157 82 103 198 98 167 131 21 18 181 196 25 220 52 212 82 178 18 6 66 195 28 15 254 200 40 37 26 70 75 225 175 132 225 135 104 105 126 136 235 186 215 47 211 166 86 177 234 184 110 254 82 35 245 33 134 115 89 170 146 2 206 122 60 210 158 46 32 118 62 102 13 59 244 157 96 47 161 92 178 65 29 239 97)
#f
())
#(45
"appending unused 0's to sequence"
#vu8(49 50 51 52 48 48)
#vu8(140 30 136 184 24 254 139 189 157 130 239 190 150 59 144 87 225 169 117 138 109 60 34 201 114 78 247 102 195 220 205 202 119 91 237 72 90 233 141 141 169 161 254 164 149 181 20 106 179 16 110 65 230 199 62 121 41 11 229 220 13 35 69 175 6 26 140 145 67 171 128 154 216 78 66 86 78 100 132 185 113 19 23 130 58 247 205 22 168 134 105 136 18 39 236 40 121 216 219 48 241 156 226 232 234 188 207 109 66 116 128 156 111 249 250 119 141 181 145 147 116 6 227 34 22 80 195 244 78 103 110 58 157 247 166 228 5 189 85 231 86 227 207 25 192 183 178 121 110 202 112 216 54 50 126 16 244 144 210 111 214 206 187 115 196 80 72 201 69 28 148 144 195 255 73 102 162 196 142 92 65 195 95 249 130 214 188 108 151 181 201 157 216 255 252 216 195 252 250 205 101 233 196 231 163 179 4 49 52 137 20 87 100 151 112 166 34 56 78 159 44 132 20 212 6 9 247 195 100 64 32 73 47 184 79 252 113 129 151 19 134 125 69 206 86 17 203 53 146 91 94 31 206 130 116 69 126 195 96 140 199 176 241 59 168 219 182 93 60 230 163 69 27 95 34 211 166 35 64 240 177 102 105 197 209 40 237 28 147 175 45 194 196 102 38 125 122 9 191 115 150 29 20 229 151 210 33 239 133 63 3 104 120 195 243 182 110 203 52 165 25 190 227 255 135 17 32 122 15 183 129 109 45 156 240 213 199 82 192 254 200 154 8 166 231 36 96 15 84 1 224 113 34 150 232 198 228 231 245 133 247 37 73 207 84 187 189 62 40 211 73 147 16 57 14 100 78 137 245 9 22 46 0 81 135 185 229 34 68 172 218 52 40 132 220 121 100 168 128 213 158 81 116 54 59 179 232 67 16 252 120 215 210 210 182 205 112 221 110 1 255 185 254 166 86 114 49 160 247 17 77 90 175 135 65 80 15 131 75 176 62 67 231 74 30 101 21 230 68 117 191 233 107 138 200 85 161 7 223 241 45 75 79 111 36 253 125 197 213 254 37 75 206 29 148 101 34 197 3 135 190 21 197 214 102 15 254 63 185 174 18 55 83 140 94 143 63 173 195 199 185 132 144 125 192 183 195 185 2 181 213 112)
#f
())
#(46
"appending null value to sequence"
#vu8(49 50 51 52 48 48)
#vu8(86 139 1 124 16 147 175 126 255 4 41 11 224 97 147 120 67 84 119 153 158 206 64 8 248 164 130 159 198 104 208 247 93 199 195 10 56 34 222 204 141 247 141 162 142 209 45 23 128 196 218 177 84 136 118 9 226 236 190 212 230 75 34 151 14 197 0 86 124 109 205 165 153 121 210 132 247 148 75 205 189 81 31 176 224 243 133 8 105 229 35 199 120 186 83 131 46 28 8 6 191 115 115 64 247 115 28 81 38 135 79 153 186 13 219 56 243 194 174 94 248 121 238 7 40 239 42 155 238 110 8 252 45 148 157 228 185 110 168 166 151 75 3 128 78 162 87 76 33 15 6 219 79 255 110 67 92 91 116 0 171 230 186 249 223 151 213 100 50 209 8 45 70 249 138 48 47 42 215 238 25 207 96 212 97 3 234 161 163 3 129 146 51 198 45 215 111 188 176 235 177 180 143 205 190 70 47 227 220 201 213 107 126 229 124 191 7 152 139 182 175 209 167 127 87 149 193 108 38 23 2 254 110 173 194 40 223 139 74 195 221 55 30 16 254 246 159 38 27 75 116 96 209 116 114 79 233 182 118 201 30 36 214 42 153 110 122 135 123 118 116 217 176 203 1 8 48 119 235 236 231 8 112 4 55 122 68 80 243 235 40 171 247 59 252 59 228 28 160 54 145 114 123 26 80 64 154 165 50 17 57 130 108 213 234 61 131 6 23 189 31 142 64 254 104 181 243 226 199 212 61 197 239 89 72 45 247 149 167 17 90 32 221 88 133 28 43 180 40 119 80 124 9 157 215 165 205 41 147 30 212 21 57 112 212 209 210 155 54 223 149 209 70 15 6 57 103 87 101 126 59 78 231 185 129 200 16 248 112 112 45 72 237 16 203 193 31 6 89 91 247 35 134 57 76 149 61 162 225 135 166 219 116 182 115 150 123 30 113 204 127 105 216 151 71 195 247 204 218 158 180 242 231 223 59 120 11 189 115 238 117 232 115 229 220 72 105 145 56 92 51 178 90 110 229 251 73 43 213 29 182 150 14 60 148 82 235 85 148 19 186 67 20 14 225 77 127 221 95 171 130 103 50 14 37 94 240 213 94 82 104 12 92 81 131 73 210 66 194 172 45 125 14 57 51 173 223 172 128 230 19 244)
#f
())
#(47
"appending null value to sequence"
#vu8(49 50 51 52 48 48)
#vu8(135 112 193 28 205 245 253 148 89 240 54 23 24 219 14 19 7 32 210 234 160 152 232 216 34 156 68 211 72 184 194 25 198 175 69 21 211 60 134 246 32 200 29 138 162 188 138 235 74 108 64 223 139 139 196 166 141 238 48 58 10 29 103 230 223 216 166 158 195 138 231 176 157 203 77 81 58 38 0 225 16 127 85 236 205 95 95 27 149 171 60 93 49 187 86 179 190 70 92 58 227 35 182 129 217 91 225 90 209 176 72 187 186 47 83 37 160 48 9 143 46 13 84 219 19 118 15 99 90 203 203 31 167 61 191 198 149 246 39 32 165 255 83 70 49 16 140 180 155 32 186 63 190 51 159 223 29 247 225 75 197 131 178 22 97 4 221 5 49 23 165 178 179 91 151 160 242 65 207 77 204 105 51 210 91 218 217 243 187 90 230 6 214 157 252 51 176 66 247 85 199 37 41 107 148 46 220 248 126 190 180 170 236 236 154 174 238 115 201 191 4 53 77 118 19 6 6 246 229 103 41 164 89 188 149 14 92 218 138 20 124 228 245 120 121 110 60 225 179 93 84 77 37 54 221 223 151 98 142 154 203 60 43 202 131 172 189 144 191 102 19 210 191 195 28 104 149 134 140 54 13 229 107 96 135 193 1 91 224 67 161 102 253 103 191 127 120 101 173 70 24 77 104 229 0 206 45 145 158 228 151 44 37 124 47 9 186 27 252 249 122 113 36 136 222 229 219 70 46 79 201 100 167 199 215 217 149 54 246 44 75 122 178 193 142 134 72 222 255 127 43 33 253 121 169 27 29 158 174 81 5 209 219 197 202 251 169 46 216 3 170 148 250 194 167 68 55 135 242 194 45 214 91 241 190 126 64 130 45 188 136 151 223 143 217 118 104 249 151 247 22 180 96 208 202 25 54 2 129 136 107 232 118 157 160 140 172 244 29 235 124 73 122 186 78 85 255 42 179 224 18 165 89 66 10 217 231 115 14 156 33 143 238 193 206 100 171 225 247 103 2 146 62 237 194 179 178 28 23 26 249 142 69 64 84 129 2 197 134 97 110 63 245 249 122 232 67 233 9 208 123 91 129 161 152 177 109 138 139 27 85 172 33 163 95 198 87 229 43 198 234 84 158 218 9 229 63 217 232 196 240 128)
#f
())
#(48
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(14 222 163 20 205 202 195 48 59 98 179 51 184 134 54 12 119 93 145 112 227 93 187 146 213 177 19 225 81 130 143 140 36 75 249 239 69 198 7 243 184 79 219 226 214 119 90 252 116 205 133 132 220 183 179 108 92 141 235 71 175 136 57 192 205 79 30 179 25 188 136 171 10 35 63 123 168 151 249 110 96 181 6 232 60 66 184 195 93 164 193 121 107 211 57 48 195 132 144 146 91 19 214 172 24 0 231 106 14 192 17 254 169 166 185 124 252 54 98 142 81 156 168 232 66 38 69 246 27 210 110 251 62 150 63 122 62 170 102 20 135 190 189 154 191 55 122 217 233 112 10 219 46 166 252 96 220 113 134 100 74 250 250 106 188 106 172 100 77 36 239 199 38 20 122 153 208 167 69 201 58 197 172 13 23 160 197 19 8 179 212 173 67 3 57 84 60 252 55 40 144 34 104 208 36 227 92 20 222 184 69 77 57 255 253 99 130 137 134 44 117 71 101 51 70 161 71 96 202 112 3 80 19 124 249 0 150 78 244 73 124 241 14 218 0 53 218 200 214 205 156 30 141 210 65 6 152 181 254 56 153 194 214 43 248 215 129 44 83 133 18 251 155 165 147 236 88 54 67 238 22 33 116 215 226 9 85 117 234 102 223 93 198 249 112 254 26 221 80 160 1 169 196 248 183 247 48 206 174 72 141 93 91 143 168 160 135 121 167 234 211 180 156 96 130 121 14 53 226 41 252 85 50 81 154 182 223 234 161 144 222 137 103 30 231 255 44 194 192 111 10 30 5 106 134 191 108 26 174 176 44 60 80 165 52 117 124 243 238 175 137 154 72 102 214 124 49 255 60 72 12 218 252 32 66 190 220 103 210 109 228 100 3 39 120 233 219 56 77 240 102 66 70 210 81 77 114 225 186 41 176 0 61 5 24 20 193 196 12 26 206 157 75 42 178 211 132 21 223 198 210 206 130 45 226 250 63 169 91 63 80 113 48 215 102 77 48 79 107 29 110 253 103 248 23 239 247 17 99 217 204 70 192 176 6 152 52 182 14 23 148 142 225 1 209 147 17 115 74 231 113 81 196 159 40 52 23 22 133 24 188 163 213 202 45 148 180 237 82 82 118 195 99 220 53 251 69 192 106 15 20 193)
#f
())
#(49
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(58 219 30 169 142 28 62 181 65 44 17 119 98 229 181 233 143 223 210 30 123 81 228 234 219 90 89 112 70 21 194 178 208 41 10 20 56 91 243 218 168 124 19 211 116 98 136 80 162 172 79 217 161 152 10 1 95 26 44 201 116 61 107 108 14 129 144 231 217 98 15 122 166 221 113 113 130 58 63 233 39 51 146 26 217 80 4 239 248 163 72 85 53 252 158 214 191 46 63 249 150 40 209 252 160 68 189 189 249 49 94 111 223 246 209 118 22 91 37 32 180 77 186 124 23 196 248 51 34 140 164 66 188 118 249 108 149 126 19 196 205 30 60 59 248 61 152 62 146 101 74 85 197 109 252 238 156 227 84 238 64 100 161 173 58 173 3 116 24 37 183 184 177 85 244 238 22 72 144 204 244 112 38 100 104 137 143 136 34 201 100 163 240 14 53 118 164 216 46 104 14 11 249 73 139 41 28 236 28 85 201 99 242 191 99 84 234 48 209 127 38 199 85 190 224 3 11 47 151 184 192 214 224 79 23 41 93 248 101 42 29 248 70 57 239 69 63 217 170 176 31 22 89 222 72 54 140 87 97 129 62 230 78 154 215 172 208 110 90 31 71 162 108 143 169 173 198 175 40 104 219 165 37 176 31 196 23 63 178 78 145 138 25 130 151 76 190 43 52 27 164 5 109 65 44 201 178 79 6 189 80 85 187 210 218 85 130 35 195 176 207 122 109 254 151 177 12 150 246 105 40 13 105 214 202 15 215 45 55 48 185 169 202 100 81 187 241 12 203 110 168 10 14 233 137 109 17 2 245 166 54 78 84 180 195 247 83 156 91 24 91 249 13 235 200 64 62 6 15 218 88 203 173 195 5 236 96 85 178 33 101 26 242 203 24 178 209 238 168 243 78 107 95 123 243 164 236 168 204 23 46 170 4 152 82 128 131 145 59 212 37 20 200 50 218 236 192 206 17 197 218 31 215 102 92 116 31 35 44 223 1 2 76 131 180 20 11 226 243 75 47 85 5 17 181 215 103 103 16 148 29 83 99 162 188 131 127 85 187 109 243 144 233 89 41 226 186 31 79 48 88 35 201 117 26 173 42 166 48 126 187 153 128 121 76 13 170 149 54 36 48 41 13 107 30 80 22 28 52 69 187 122)
#f
())
#(50
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(134 64 79 26 37 27 119 8 145 243 251 225 166 181 122 221 26 13 106 182 19 126 254 190 100 5 207 55 160 11 38 240 165 172 191 97 208 253 70 82 71 128 213 84 205 196 214 198 245 221 16 14 58 42 144 195 222 82 44 84 145 253 67 60 85 151 38 224 109 163 160 237 115 97 48 153 251 23 199 180 211 35 75 21 44 228 224 230 210 98 32 212 159 94 191 154 166 93 52 168 58 198 100 244 122 209 226 71 201 161 242 145 110 230 229 25 194 180 163 238 244 175 177 4 156 95 147 81 225 94 67 173 141 102 208 81 46 218 174 61 202 14 67 220 230 12 181 35 226 46 193 69 151 198 193 218 61 87 17 66 177 54 157 45 204 124 130 152 69 241 197 157 35 210 147 137 207 240 246 221 237 196 177 130 65 210 102 222 86 88 218 123 73 17 134 35 178 18 230 155 137 27 54 152 223 208 246 49 18 215 166 58 241 190 154 143 139 168 141 120 227 238 181 216 70 247 28 13 95 110 193 146 247 10 104 96 136 149 62 108 78 225 230 70 62 101 118 251 24 128 98 9 34 93 164 110 181 92 216 136 129 45 86 63 141 13 212 3 204 143 170 46 201 132 251 0 0 168 168 71 249 87 47 58 4 71 162 87 95 235 34 12 185 40 171 176 25 232 246 36 211 250 26 106 237 44 70 64 109 205 155 19 133 127 8 166 156 181 154 158 201 54 41 95 103 99 42 4 214 130 48 218 68 82 164 173 218 35 193 42 241 89 240 181 253 90 250 40 43 69 67 101 203 94 71 198 150 160 14 17 2 177 189 125 71 141 109 211 92 198 138 145 104 14 111 126 191 232 185 128 134 241 207 160 186 137 57 29 149 115 56 136 9 56 120 190 125 131 237 88 160 215 88 198 64 119 252 66 8 157 221 178 244 171 37 179 18 255 46 76 213 69 165 7 176 186 94 152 55 44 159 97 200 248 232 84 205 69 93 3 56 47 93 149 169 133 164 94 23 181 207 246 173 62 117 158 76 0 251 191 204 115 225 178 246 149 249 193 3 248 121 176 95 13 45 122 139 137 7 11 165 120 165 107 187 79 7 44 248 29 177 59 219 44 244 223 188 116 70 119 177 161 117 55 61 7 85 51 252 153 7 138)
#f
())
#(51
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(182 247 148 113 49 114 105 90 230 169 182 193 4 137 243 173 25 251 211 99 50 153 25 234 129 130 76 126 57 76 56 241 73 138 155 237 38 231 237 190 25 116 254 176 152 209 132 175 67 207 230 226 236 108 60 249 183 148 81 249 110 11 212 154 9 166 119 154 53 24 38 70 28 23 22 127 71 55 3 37 89 154 48 170 97 54 80 132 204 213 5 233 1 40 234 143 152 220 84 240 141 14 37 49 251 3 193 9 54 12 63 173 176 29 89 126 197 30 152 223 23 57 115 124 110 71 123 165 244 222 45 32 2 86 2 252 88 88 144 12 183 33 218 104 24 177 43 109 158 200 84 220 91 10 77 71 47 32 167 220 106 27 161 91 85 196 245 198 236 40 76 156 220 114 62 32 138 49 196 163 160 173 83 22 175 138 131 131 144 96 223 219 233 232 14 112 72 212 207 76 108 112 174 29 179 5 151 212 96 172 114 123 65 8 142 33 169 103 228 57 116 4 132 130 254 172 59 118 211 254 37 204 97 98 106 212 137 41 248 58 59 23 5 45 92 163 96 37 9 94 224 110 122 118 124 226 235 244 14 8 130 25 25 66 237 127 17 128 203 12 68 157 141 211 83 6 227 195 230 208 56 129 86 139 191 74 218 193 39 79 53 78 52 88 4 230 91 221 250 84 192 252 52 15 238 117 6 114 249 162 98 171 43 84 234 61 76 23 182 247 160 133 54 36 80 123 50 15 169 74 242 161 98 244 1 166 137 139 44 221 167 162 89 80 87 147 70 86 134 57 69 232 227 161 28 72 151 252 233 81 51 252 77 254 162 121 233 68 100 136 156 88 231 72 49 22 85 153 9 196 5 212 117 77 188 165 156 101 8 46 144 148 209 22 187 122 109 69 127 157 110 253 9 88 130 207 65 47 106 235 156 4 252 230 80 140 164 117 18 252 155 128 42 87 200 201 136 15 102 201 9 40 148 33 122 104 31 99 109 40 65 9 242 186 30 204 111 198 33 3 238 210 140 147 131 44 159 94 192 76 190 83 95 249 172 72 150 103 212 138 30 120 222 248 104 12 12 184 17 116 189 81 218 228 13 244 16 109 101 35 153 53 69 88 99 56 144 38 225 35 22 83 72 244 106 30 200 70 193 4 63 169)
#f
())
#(52
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(220 136 102 41 129 159 147 219 154 165 31 249 111 51 163 237 118 168 63 138 239 17 23 142 89 103 133 192 104 25 91 28 165 58 149 24 150 85 135 134 178 203 57 51 172 18 202 215 113 151 169 74 220 199 117 66 172 242 240 217 187 115 62 198 70 76 20 221 225 95 75 29 210 129 230 37 106 152 134 253 200 187 244 208 124 191 49 78 132 105 47 195 87 30 47 38 162 183 252 68 245 27 237 182 104 209 9 167 183 24 27 43 233 102 99 233 188 252 160 232 183 62 121 56 27 253 149 233 237 122 22 34 207 25 52 253 24 208 241 187 184 27 0 2 24 166 236 199 226 107 32 204 154 142 169 108 156 52 116 44 183 36 63 200 19 92 137 168 183 231 147 187 196 51 239 9 249 227 200 227 168 19 176 131 23 23 172 7 106 94 28 197 143 80 85 116 92 150 210 84 34 176 244 53 132 75 236 5 4 2 41 49 179 207 242 122 70 115 205 104 125 7 27 4 66 234 239 68 220 1 206 156 194 78 35 157 168 89 99 165 255 80 209 109 116 174 155 69 65 140 83 6 137 91 181 151 191 100 224 205 10 6 188 219 47 8 187 53 230 114 132 26 9 46 169 114 62 214 101 18 154 238 180 15 222 238 125 132 56 149 165 117 226 221 117 113 101 36 118 82 183 110 227 157 211 121 184 163 195 157 183 247 200 148 101 3 248 177 228 152 253 151 220 18 248 71 242 244 239 38 158 179 126 29 96 43 45 242 73 221 243 245 196 169 156 229 208 212 193 49 216 144 83 232 174 132 138 42 111 40 31 117 85 250 42 97 120 44 219 253 182 54 122 95 236 156 97 245 196 226 238 50 0 53 41 195 60 138 79 112 227 9 151 204 74 116 198 158 16 122 166 88 18 44 50 171 134 78 27 51 247 189 155 176 197 50 158 13 49 149 191 247 17 151 47 193 26 16 88 14 22 192 244 4 155 34 169 85 135 33 114 248 253 76 196 6 72 90 244 92 52 190 235 169 106 35 231 129 131 164 0 189 211 169 211 50 141 93 43 59 158 178 218 47 111 107 149 240 75 109 165 2 208 180 177 175 151 4 100 67 9 206 57 55 137 81 204 134 160 194 119 252 42 118 241 226 195 154 138 149 228 71)
#f
())
#(53
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(90 140 36 34 104 212 171 202 41 21 231 172 152 159 204 126 20 205 255 121 130 118 52 135 234 214 103 191 206 250 177 2 45 170 225 159 19 122 137 33 226 78 19 38 219 22 24 117 124 50 16 205 103 199 42 137 60 9 225 18 145 84 70 88 115 103 247 167 70 157 12 252 31 149 228 15 209 159 191 101 58 225 173 80 90 113 209 45 173 237 227 161 87 33 211 201 23 215 130 42 131 101 197 114 74 203 67 244 82 131 81 26 62 143 246 229 149 137 116 234 221 26 70 41 106 119 55 128 45 4 41 31 50 187 123 255 234 250 141 209 50 81 115 250 236 158 57 50 180 84 150 240 170 127 222 145 177 88 109 105 86 132 194 53 54 6 143 16 23 184 55 173 43 33 35 141 126 222 144 40 8 242 231 86 219 98 11 241 69 174 98 251 157 224 127 167 72 217 240 217 133 153 53 142 186 58 194 69 113 208 21 228 77 190 63 66 39 195 105 229 81 0 86 98 202 66 113 24 119 206 226 124 2 163 65 0 91 253 57 62 180 42 19 132 8 142 196 43 76 165 116 255 84 139 222 201 225 18 92 103 179 150 218 118 89 68 211 86 84 119 96 67 186 171 93 198 175 54 13 121 156 215 10 98 85 165 105 28 213 208 47 108 250 207 214 216 116 124 115 87 80 177 181 166 116 108 175 200 35 125 51 173 29 19 3 120 132 162 27 123 165 200 151 64 92 52 228 221 212 221 255 175 222 68 46 191 14 52 232 139 16 24 68 189 177 84 46 190 67 46 212 56 172 124 247 246 161 121 142 143 129 192 194 150 226 102 167 16 232 49 40 198 222 49 125 249 90 1 253 96 254 137 155 202 137 133 105 193 78 137 237 186 215 184 71 103 94 81 20 41 191 34 187 109 164 247 240 31 131 41 22 235 140 146 229 57 19 180 51 173 164 62 42 233 9 187 177 58 5 193 116 189 136 39 204 24 25 132 6 110 198 135 128 28 50 94 27 105 75 143 194 172 20 6 96 83 194 10 181 47 158 52 195 188 75 17 88 76 227 229 53 5 34 241 236 204 120 70 84 27 159 72 87 162 10 19 202 175 250 153 183 192 199 199 87 92 230 49 67 34 47 217 191 36 238 129 147 208 135 130 58 28)
#f
())
#(54
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(58 231 199 78 89 125 240 101 225 98 212 194 161 131 167 218 196 143 98 129 197 15 94 158 212 56 46 106 208 223 50 86 162 156 148 35 3 140 86 66 193 125 45 40 183 51 192 204 137 234 190 24 137 132 127 62 136 56 137 244 195 124 246 26 129 37 115 249 131 253 176 200 144 124 78 193 90 70 239 191 198 106 49 116 224 215 247 24 173 40 203 134 188 211 222 50 145 35 33 136 47 52 43 71 190 215 59 36 61 156 1 0 62 209 115 137 176 129 1 119 91 169 121 247 193 93 194 226 127 215 198 114 73 179 139 104 33 19 115 89 44 89 197 65 179 36 200 130 113 194 17 68 233 36 231 139 55 164 13 164 35 249 182 28 89 209 175 7 39 255 166 233 7 25 199 50 48 254 239 100 98 87 25 134 24 91 71 218 195 220 199 56 24 232 65 85 201 201 48 117 228 84 195 115 156 8 77 149 46 223 26 108 226 8 203 189 96 89 95 193 138 197 96 192 149 82 38 57 100 108 182 120 121 48 202 118 176 159 228 10 19 162 152 124 153 127 69 223 169 238 152 26 243 67 126 79 233 44 177 233 9 113 99 53 20 44 185 139 115 66 141 15 134 99 13 8 181 180 139 146 100 168 105 204 104 192 194 95 48 119 77 20 92 80 103 100 106 67 209 97 49 61 11 220 210 228 96 44 252 193 206 142 191 201 24 115 100 53 66 173 206 165 128 108 124 82 137 93 119 227 101 162 102 94 246 189 42 73 234 134 169 104 51 120 107 163 73 242 237 110 238 244 252 90 212 90 243 241 47 189 87 188 203 160 219 35 90 197 101 148 217 185 103 31 155 142 90 94 148 202 25 216 78 191 104 195 213 136 177 111 20 220 136 6 205 187 247 150 143 103 205 37 103 75 162 142 5 31 53 218 184 150 144 131 65 17 161 189 47 200 194 12 18 160 181 23 254 5 158 35 24 210 40 130 230 148 45 225 150 213 44 209 166 59 21 148 53 95 193 244 147 119 152 6 4 114 238 209 199 145 157 48 78 106 203 138 192 34 251 86 163 42 11 72 218 137 224 158 248 87 138 83 241 80 172 71 150 18 78 16 28 83 31 90 237 139 242 160 16 99 140 144 238 186 239 139 157 76 214 135 28 149)
#f
())
#(55
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(180 137 174 240 234 122 60 113 113 70 138 145 19 45 48 187 167 89 227 80 98 137 2 59 141 65 78 91 66 130 158 129 236 114 87 57 47 173 130 210 213 76 188 38 38 223 79 144 106 211 232 153 242 2 223 109 245 66 138 185 146 196 226 195 61 59 72 18 195 249 235 169 210 16 190 24 69 179 115 99 105 141 107 179 113 48 3 39 122 187 3 99 178 105 137 163 12 21 26 101 160 88 155 178 92 5 55 96 33 155 210 230 140 75 94 10 153 155 100 207 121 89 224 93 196 39 167 153 234 127 128 131 91 68 174 244 73 196 206 213 215 8 169 225 47 130 211 244 52 15 152 235 152 54 209 71 29 118 151 81 136 218 224 75 188 179 75 191 91 101 236 224 68 57 125 63 5 202 115 79 249 120 207 58 236 214 239 143 45 117 105 231 215 130 138 190 224 104 68 83 20 185 171 20 62 221 112 195 71 134 57 9 57 61 33 125 124 195 90 46 60 18 40 91 234 109 132 139 240 202 199 83 14 48 106 223 63 18 128 68 184 62 62 42 12 251 45 34 254 176 175 76 30 147 171 121 183 6 201 3 204 10 19 207 107 241 122 126 35 221 189 14 146 182 137 87 221 28 248 11 203 131 167 106 144 1 19 103 18 149 108 238 196 82 61 155 225 156 113 244 69 95 44 106 175 47 109 190 24 123 80 205 242 88 85 179 216 98 66 64 76 85 68 145 154 237 81 41 240 126 46 36 81 28 121 74 170 117 17 37 151 167 146 254 163 82 225 200 35 14 126 189 182 212 128 137 239 216 184 94 9 253 168 216 243 23 216 135 146 252 126 194 233 105 62 222 228 223 241 209 42 205 86 140 145 35 155 47 202 75 109 95 183 187 143 234 137 153 118 163 63 176 231 33 98 177 201 115 123 248 73 146 210 16 246 55 64 16 24 122 252 2 252 39 169 126 7 207 102 4 216 238 112 39 113 137 174 151 218 10 134 95 147 48 124 128 41 53 142 190 75 161 176 74 94 6 131 58 192 228 104 207 29 223 4 73 8 132 199 253 91 119 109 87 141 207 115 255 200 19 239 120 209 131 97 192 244 221 170 69 175 219 208 47 92 78 112 130 173 233 17 178 198 157 11 198 77 98 56 203 187 249)
#f
())
#(56
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(207 144 238 104 19 219 25 253 38 166 252 222 33 133 210 191 237 245 219 225 106 135 247 179 224 67 121 132 88 85 69 0 145 103 81 135 187 67 203 76 131 148 163 133 119 184 139 117 11 54 89 218 132 198 222 115 197 156 99 186 174 57 7 113 35 25 47 222 7 182 48 219 235 29 245 84 98 84 26 2 134 173 96 41 249 63 97 233 84 217 243 170 190 21 115 45 1 48 229 48 235 252 29 255 141 132 107 55 144 78 167 39 129 171 123 141 136 227 28 165 179 89 64 231 56 230 89 79 156 128 30 186 203 42 162 39 244 131 246 61 82 210 32 13 66 202 18 97 226 28 174 20 36 205 228 107 15 88 151 58 61 115 235 166 243 114 99 123 54 121 170 49 51 99 33 80 31 28 11 40 231 53 130 159 132 29 230 49 119 195 119 32 32 205 68 100 130 167 108 7 0 64 56 89 217 80 110 50 201 154 251 12 246 116 162 60 82 117 82 148 103 230 95 13 214 233 184 56 73 58 148 160 175 78 226 23 25 39 11 168 59 25 249 62 235 119 5 218 217 89 184 55 242 235 154 108 106 202 141 110 222 170 186 164 49 117 71 125 100 79 164 178 179 245 168 162 67 177 152 104 221 189 74 25 159 5 33 244 240 11 145 57 159 237 215 247 164 93 246 239 20 93 84 226 1 158 216 220 86 242 7 225 164 209 22 162 222 197 122 175 104 178 184 184 71 82 76 193 253 32 128 99 231 77 80 139 254 100 141 216 195 217 9 179 206 225 182 117 186 143 198 96 203 209 1 11 180 205 125 243 130 92 59 34 121 50 26 144 21 161 200 128 34 201 65 219 18 150 132 225 167 210 129 126 139 54 46 93 154 175 172 142 103 89 35 171 142 118 175 248 170 197 110 138 104 42 120 148 135 80 16 118 246 100 225 106 251 92 231 111 85 11 203 203 14 66 80 121 16 0 88 92 231 98 89 76 47 72 112 22 84 105 27 13 123 9 119 13 124 157 75 36 114 157 65 56 153 86 84 254 215 4 196 123 241 179 52 21 82 225 20 55 136 99 11 232 141 68 231 131 62 62 118 246 143 60 200 22 149 209 81 77 170 220 18 52 158 94 76 172 87 69 62 38 44 204 222 65 35 131 150 221)
#f
())
#(57
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(69 197 61 185 162 52 92 77 128 141 107 48 157 232 43 185 11 113 67 31 179 205 121 82 164 141 58 169 10 188 201 187 120 1 205 204 28 227 36 217 204 147 20 19 114 25 81 29 189 125 95 97 149 191 183 140 133 88 106 233 148 14 210 158 215 78 192 54 249 77 68 12 156 182 117 15 163 225 56 158 60 248 106 207 119 103 30 49 201 182 135 111 128 34 93 117 191 24 194 181 45 150 186 34 116 201 30 28 106 15 24 201 82 128 15 10 151 90 9 229 177 122 238 84 214 204 5 67 128 134 187 113 18 59 212 3 180 174 158 5 35 150 44 209 224 229 163 107 176 65 31 66 150 87 171 7 21 38 155 101 129 199 136 205 161 126 128 107 253 206 166 194 68 209 86 192 23 40 68 110 18 17 110 52 211 115 146 39 129 123 224 120 64 102 96 216 184 72 129 21 8 69 174 220 41 92 191 30 131 189 59 208 187 127 43 57 122 54 35 236 73 222 88 122 77 37 119 226 141 40 137 49 23 10 122 17 154 116 234 154 26 211 126 6 242 145 59 88 132 207 86 63 75 54 126 250 144 14 222 182 148 143 216 26 36 135 122 66 150 54 219 182 141 148 214 162 167 53 20 189 196 241 152 52 143 114 172 213 125 2 46 41 91 169 130 155 237 247 86 0 56 24 183 34 205 225 227 230 85 149 178 141 243 185 91 201 138 89 220 51 119 208 190 208 128 66 33 202 203 177 245 164 243 248 211 236 205 136 55 7 132 71 190 104 74 255 250 220 239 89 194 64 116 113 114 179 8 129 205 150 7 5 216 140 54 76 208 34 228 56 161 194 0 185 138 214 2 36 109 88 2 234 113 160 251 172 190 98 80 42 176 241 237 49 218 150 171 82 147 201 171 111 169 181 38 116 97 157 53 37 164 252 90 157 90 227 40 20 248 240 226 132 161 109 11 121 23 165 120 105 43 147 75 243 214 46 171 251 47 21 83 40 72 159 137 249 13 186 149 178 120 4 25 164 16 252 99 123 149 58 157 119 84 154 135 126 232 150 151 126 22 110 58 161 17 35 217 189 37 255 84 114 132 83 196 180 42 91 73 61 252 136 163 234 24 141 89 191 72 184 215 90 96 139 141 151 209 152 105 36 131 212)
#f
())
#(58
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(135 242 45 213 218 227 96 137 226 6 210 63 250 69 250 95 11 5 206 237 123 53 178 69 88 217 253 231 73 64 61 26 144 146 154 90 52 242 91 109 219 68 197 228 15 32 132 183 115 147 237 213 173 140 220 59 194 133 58 16 84 82 72 56 188 26 79 112 242 224 67 212 57 124 51 154 170 138 139 191 145 139 161 146 178 37 231 88 87 110 159 58 11 32 168 211 206 121 80 98 35 164 185 38 250 27 195 2 185 141 55 165 51 130 176 77 142 118 228 115 150 137 176 9 72 18 216 46 41 20 142 41 123 33 113 115 121 7 81 3 108 199 200 0 180 168 6 20 161 143 238 155 72 133 202 132 26 105 171 68 174 173 203 129 206 216 97 46 193 21 150 170 19 106 46 240 69 123 46 44 73 36 235 135 219 207 229 28 207 180 210 41 219 39 93 139 153 86 196 205 213 114 176 37 93 8 184 239 217 54 140 5 111 143 20 125 40 105 15 24 49 236 242 109 112 198 101 51 200 118 22 173 29 188 7 76 208 211 176 88 233 58 11 109 241 7 248 215 19 22 31 163 141 145 104 33 187 193 43 182 84 215 210 60 89 23 90 56 105 74 4 13 26 176 53 146 21 61 46 247 66 59 212 248 236 165 116 31 145 172 106 212 242 94 127 212 125 31 65 206 99 168 134 175 255 251 207 113 236 27 239 57 220 110 240 159 25 40 195 90 77 18 106 117 51 42 49 188 159 248 33 159 22 193 34 107 135 42 149 248 157 3 56 128 132 167 226 181 95 156 4 33 30 193 251 89 150 111 174 52 70 249 57 10 74 54 7 230 251 35 195 102 64 17 49 41 107 221 150 28 118 229 241 241 158 178 95 248 216 135 207 95 14 40 178 169 91 216 218 98 124 244 103 58 195 43 54 140 246 47 211 231 188 158 93 28 167 142 228 6 183 28 94 150 82 81 216 86 125 154 187 5 177 109 186 92 234 211 1 199 122 71 113 240 142 59 41 14 231 120 234 77 124 67 102 106 56 142 251 229 177 161 99 227 209 68 23 196 179 24 83 147 68 232 101 146 228 99 116 193 202 27 20 35 250 187 230 190 190 39 96 103 236 194 95 196 83 24 14 11 25 117 208 27 188 3 115 66 206 189 235 94)
#f
())
#(59
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(141 62 149 166 211 231 88 223 246 207 50 7 2 246 134 90 177 186 186 60 123 192 30 94 110 27 245 1 227 118 110 158 252 122 62 44 115 209 174 6 219 196 2 82 25 234 98 117 169 42 75 54 30 171 136 141 16 5 54 230 32 204 224 7 186 58 167 169 23 246 231 21 226 156 190 236 178 131 8 184 115 213 227 221 75 97 156 72 75 154 61 128 86 117 112 228 38 177 89 66 195 14 157 57 135 144 153 210 182 228 131 175 55 82 57 115 66 183 208 252 78 85 107 200 52 138 244 173 40 10 61 27 30 210 95 24 184 102 168 191 190 210 67 204 82 87 225 177 229 181 164 82 127 38 201 150 145 242 190 139 214 230 239 117 146 134 114 69 139 196 205 75 208 66 32 184 30 231 11 208 17 16 65 214 18 246 109 87 216 179 60 37 30 46 246 157 105 55 119 204 159 168 213 201 41 157 38 67 247 207 149 246 153 45 180 74 197 82 74 201 243 25 60 212 209 187 209 188 165 48 154 131 13 2 60 18 155 255 171 84 65 196 6 87 47 164 11 34 254 221 118 253 35 176 79 60 104 113 186 238 98 28 189 93 174 126 101 128 166 147 1 5 248 66 249 178 19 88 4 133 177 26 1 185 120 139 12 39 146 111 96 148 133 19 69 223 180 127 94 249 10 189 20 65 33 115 105 75 138 20 96 155 205 53 187 147 249 200 213 171 204 241 105 122 28 129 9 58 251 216 59 151 45 84 36 25 90 230 174 224 42 124 145 220 177 152 68 14 48 91 38 91 26 110 17 193 210 234 179 191 125 45 75 241 122 29 165 105 71 1 80 22 116 131 141 78 93 121 195 176 5 164 207 8 166 189 248 206 242 174 117 183 224 84 238 109 21 171 14 224 72 151 86 0 96 221 81 77 7 61 147 82 213 1 65 226 68 76 158 218 113 94 104 184 166 194 79 30 113 125 213 56 82 252 181 188 253 13 41 87 248 60 198 122 124 95 106 217 35 94 216 53 83 99 224 33 17 146 95 170 191 143 120 243 56 121 183 32 86 149 33 123 120 15 186 233 246 158 207 72 221 60 222 16 2 103 169 20 168 30 205 2 26 208 253 175 42 13 4 125 246 138 10 27 247 60 24 168 206 232 101 222)
#f
())
#(60
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(93 28 92 145 3 59 16 37 216 31 174 168 172 215 104 19 156 17 42 54 105 206 30 187 16 17 81 174 37 127 41 155 165 19 139 126 162 206 18 62 146 123 253 205 136 101 220 9 21 79 178 173 244 14 215 186 130 216 231 87 221 248 54 48 99 37 158 141 48 210 75 22 157 77 94 152 185 17 206 213 77 136 53 60 119 103 146 44 80 45 179 59 217 180 244 220 207 182 245 51 90 14 24 57 195 20 5 244 201 96 185 215 166 13 120 39 164 5 243 186 182 41 106 207 172 168 68 57 42 47 59 184 36 2 156 32 151 71 227 89 97 169 238 166 5 177 42 147 19 77 11 36 253 103 120 220 16 105 155 252 22 10 177 46 57 69 92 2 125 244 71 187 77 156 145 94 207 186 120 214 230 110 144 76 91 174 37 169 252 215 139 132 105 9 2 219 173 193 79 99 106 202 225 78 255 216 74 162 129 18 37 46 7 6 38 33 6 252 2 236 25 30 137 24 7 190 49 4 97 52 255 121 34 240 126 136 115 127 250 155 211 71 50 248 127 61 69 154 83 229 224 97 254 188 68 218 241 141 13 240 76 241 37 234 147 6 74 204 63 37 118 82 255 30 185 170 228 174 169 33 221 137 252 40 253 125 203 42 175 229 217 54 110 15 106 17 167 189 15 103 175 182 45 18 239 219 83 114 152 215 135 195 40 57 9 81 218 61 119 141 16 116 19 178 56 234 102 199 102 193 161 195 204 54 70 121 248 249 144 152 161 205 43 127 149 5 231 98 108 105 6 200 55 222 177 177 88 126 44 75 104 12 90 129 51 120 43 134 63 212 186 166 184 121 162 146 49 42 190 118 73 44 254 224 60 32 121 14 95 247 199 104 242 6 208 180 227 19 141 70 204 81 90 37 186 224 210 205 146 25 247 139 155 147 42 38 113 9 126 166 81 247 9 71 124 22 73 171 60 140 152 117 231 110 250 199 11 220 112 103 18 23 170 21 198 190 36 124 54 115 84 68 60 126 82 112 101 253 24 116 214 237 241 130 102 0 102 62 171 97 9 123 208 7 71 131 150 190 42 45 131 125 68 187 162 135 102 4 138 160 43 56 96 180 108 199 25 21 121 135 135 237 89 224 109 131 111 70 236 12 49 192)
#f
())
#(61
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(43 94 236 251 64 100 165 103 72 181 111 206 247 146 119 224 94 200 39 41 131 89 223 72 196 28 117 166 83 85 194 60 103 141 97 107 242 95 8 244 71 97 174 125 188 125 22 21 67 180 57 76 86 135 215 98 200 95 173 176 234 166 224 152 173 230 187 128 223 233 34 184 130 49 252 41 110 38 148 17 189 64 173 63 24 198 175 255 102 164 187 37 153 98 138 166 250 194 94 78 185 150 205 234 189 246 112 3 39 247 63 38 144 91 165 146 58 152 144 142 161 63 50 101 56 225 66 56 5 183 93 102 55 38 32 41 195 69 203 15 220 124 106 207 8 151 241 56 235 63 123 121 118 254 18 149 135 212 72 92 190 172 173 193 111 195 29 202 255 186 235 123 181 28 73 164 248 189 177 94 20 163 208 186 149 143 51 14 227 215 232 5 219 116 116 196 167 191 220 127 38 164 124 248 42 227 90 88 149 89 255 123 57 166 5 100 163 252 59 158 78 117 155 252 231 110 30 40 68 54 141 109 146 224 232 204 190 116 4 92 179 202 240 255 188 71 15 186 199 72 247 43 84 85 185 238 56 166 21 191 197 0 153 35 137 8 2 4 42 77 39 63 189 81 187 27 0 215 137 4 186 6 176 213 196 37 51 54 22 175 125 231 255 252 137 66 163 212 47 121 234 107 60 92 6 150 248 16 230 3 59 5 4 174 61 178 198 223 131 152 43 234 100 193 216 4 53 115 172 51 16 255 193 126 33 13 220 228 182 26 191 22 74 94 68 117 145 224 114 182 125 1 83 123 82 92 83 136 175 232 118 54 1 28 167 10 15 46 117 243 175 162 137 161 217 222 40 148 231 248 55 123 173 223 37 32 25 244 119 14 177 217 157 74 71 62 146 249 121 32 102 196 172 144 25 194 224 145 90 116 172 191 169 204 136 130 164 173 36 58 7 118 126 119 36 108 88 97 129 105 87 139 166 162 74 244 239 36 252 0 89 18 70 104 255 152 142 88 170 79 101 74 253 129 56 60 207 156 128 226 239 215 183 246 90 172 51 105 212 202 178 83 209 114 90 65 76 22 157 92 37 208 139 221 128 154 242 100 221 240 160 192 217 95 27 58 204 113 161 219 0 189 62 255 245 83 234 120 112 62 84 241)
#f
())
#(62
"including garbage"
#vu8(49 50 51 52 48 48)
#vu8(104 200 230 121 108 12 171 111 177 66 189 65 19 84 182 66 70 145 2 174 9 78 249 78 17 87 183 4 171 75 227 110 21 128 173 241 206 171 50 225 201 74 43 172 21 75 17 192 216 10 132 40 74 135 213 229 164 142 208 159 8 99 155 233 199 52 158 44 139 109 82 25 10 36 27 10 250 96 164 153 57 129 177 42 89 163 143 47 248 158 20 205 140 118 95 254 122 7 253 106 171 62 102 174 198 177 91 160 66 221 101 118 186 149 38 216 165 56 22 168 222 195 58 129 180 252 139 94 108 68 71 244 219 38 24 66 193 44 215 106 63 20 82 105 198 164 136 246 193 186 241 22 98 78 105 114 112 241 15 142 236 70 47 235 199 152 191 189 240 149 89 50 113 205 244 125 179 71 218 24 244 196 112 71 38 56 183 17 218 103 101 74 111 245 65 71 237 134 174 171 112 246 216 92 166 44 74 55 76 245 109 10 173 163 142 117 200 97 19 67 179 187 187 122 90 73 191 168 172 50 124 112 207 10 22 191 138 112 12 149 252 118 26 12 174 169 148 185 165 16 137 221 144 212 195 87 7 23 16 47 150 92 247 141 32 21 187 110 177 151 17 213 22 19 34 11 225 201 169 100 49 158 218 155 215 103 216 212 44 99 144 177 159 5 62 117 158 2 124 239 63 24 67 29 202 158 195 3 193 117 53 106 89 123 202 136 7 231 46 32 199 31 93 24 40 94 150 234 166 111 246 50 161 55 141 26 56 167 108 28 215 18 12 88 135 168 178 88 61 100 206 179 245 219 185 160 234 49 81 232 201 232 97 64 184 187 188 94 0 184 241 70 123 31 125 206 228 146 4 204 67 91 161 41 223 195 199 20 241 68 249 182 50 43 186 113 132 150 27 73 96 57 251 95 1 90 243 75 85 226 235 47 142 174 38 198 58 153 231 180 160 75 67 239 214 27 105 182 112 175 195 159 94 125 88 6 50 15 154 111 140 133 186 190 251 97 125 245 55 226 34 143 133 105 109 254 46 44 202 60 5 121 149 203 131 142 176 243 154 57 15 37 114 65 222 95 26 253 189 251 51 223 60 193 9 141 183 56 59 201 180 122 60 60 104 195 246 107 143 32 40 212 23 108 0 85 100 121 169 211 45 150)
#f
())
#(63
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(82 60 144 100 147 178 2 221 12 232 137 63 49 173 130 140 129 240 113 64 253 192 113 240 48 230 244 74 254 164 251 6 125 252 68 184 14 218 209 106 38 161 162 238 28 4 142 20 121 146 79 17 78 235 254 246 151 109 89 91 170 119 206 188 229 249 85 235 52 201 240 166 212 210 160 81 141 238 240 11 138 63 214 115 80 137 7 183 196 110 131 38 187 135 79 89 62 163 86 36 137 220 3 49 90 94 41 245 130 35 161 16 190 85 195 123 184 133 9 54 159 132 226 24 213 56 67 159 19 212 110 163 21 54 118 150 41 159 57 102 86 13 40 42 44 131 90 148 121 112 146 66 202 47 73 217 10 52 17 146 179 42 234 31 254 105 162 210 68 78 172 243 171 146 192 131 232 89 63 107 160 108 252 183 160 232 67 214 184 48 199 178 203 158 155 171 18 73 52 142 199 185 122 204 198 65 92 134 53 63 219 21 139 32 8 162 123 170 18 224 137 128 242 22 167 36 190 231 99 44 156 73 89 92 71 230 30 86 84 72 100 95 179 179 73 105 158 163 168 2 50 86 247 110 141 246 19 245 147 100 174 245 97 204 151 11 191 148 84 85 24 1 45 88 152 236 65 6 175 89 44 95 238 85 24 97 199 233 102 89 228 127 19 59 108 78 123 99 99 17 5 54 127 218 190 179 206 56 192 51 213 169 101 164 219 190 209 175 246 97 4 223 50 210 55 192 38 78 68 205 147 141 67 53 254 92 103 219 110 139 233 202 121 55 61 236 38 49 152 88 84 250 1 12 181 190 146 146 42 22 149 214 228 126 1 58 13 119 40 243 160 223 213 25 181 78 12 218 189 194 144 244 182 235 44 78 59 16 32 85 170 29 144 5 82 15 0 83 42 142 243 231 109 110 107 36 112 242 112 170 36 86 197 190 161 219 146 75 134 59 151 73 228 176 157 205 24 106 14 15 188 168 179 178 247 185 140 182 78 54 130 101 155 61 232 14 58 215 35 52 66 105 233 8 195 147 232 249 183 45 181 119 109 81 38 46 154 89 242 117 229 110 97 44 16 97 130 116 93 14 94 141 82 153 134 14 99 31 151 176 165 53 101 52 167 114 76 84 18 221 207 82 200 86 40 174 89 31 64 120 1 73)
#f
())
#(64
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(48 176 197 150 171 132 151 141 193 227 126 136 204 122 247 136 4 124 228 108 6 248 4 199 73 50 44 10 214 191 43 197 96 140 248 167 172 163 191 105 90 146 46 130 110 181 195 230 75 70 7 157 35 69 124 159 176 185 138 166 172 180 112 222 5 250 97 46 157 250 252 196 146 190 173 23 138 216 202 198 115 66 15 93 165 214 9 181 24 241 208 185 192 250 172 21 75 147 16 237 18 101 41 136 251 205 125 92 231 87 208 112 74 90 160 181 20 67 69 248 92 252 181 238 49 56 220 134 203 194 145 113 62 80 144 135 24 250 169 186 223 238 188 183 60 239 154 104 125 180 184 17 217 150 173 146 193 169 175 126 68 216 117 132 44 239 20 238 89 214 161 243 53 212 203 185 228 27 97 85 219 182 148 225 90 20 135 214 100 229 200 230 195 121 86 173 18 146 149 133 2 161 244 221 117 224 142 253 177 173 66 118 251 197 195 24 4 147 124 177 117 188 230 224 247 52 170 173 89 239 39 199 126 198 204 98 103 189 37 4 85 2 117 129 86 92 249 27 206 194 127 98 202 94 154 30 27 139 72 251 71 249 26 8 110 211 0 192 155 223 94 10 76 195 110 127 79 164 244 49 204 91 0 199 247 33 45 195 33 233 212 131 119 3 151 189 216 225 178 45 237 109 1 173 45 18 234 66 83 174 34 60 120 107 71 79 87 81 160 70 53 125 124 175 67 34 230 26 213 92 34 121 171 6 218 220 255 99 95 174 94 221 45 187 109 66 151 89 161 115 207 187 200 211 213 55 235 108 218 145 27 41 12 11 3 150 180 176 75 204 154 89 167 59 152 91 69 242 169 22 18 223 87 252 118 10 126 235 160 74 177 216 231 40 199 226 252 70 21 83 234 254 33 210 175 56 130 177 207 149 56 28 117 151 20 96 62 66 103 72 151 114 148 3 138 213 40 216 46 131 56 247 64 60 120 215 140 212 208 254 200 246 176 248 203 220 31 188 51 246 215 15 28 247 146 203 112 102 84 7 104 164 76 67 81 49 149 18 234 112 178 8 49 183 6 130 185 108 23 132 49 106 27 231 55 130 110 143 64 34 189 79 168 67 150 248 220 211 238 75 167 21 66 182 198 191 59 62 169 237 241 80)
#f
())
#(65
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(130 76 169 152 250 214 161 144 103 222 197 120 91 225 57 124 142 139 52 28 130 183 12 2 150 12 230 66 132 205 163 65 187 56 165 241 248 106 66 139 205 215 8 94 147 145 87 202 98 122 24 168 35 184 227 172 241 82 57 26 139 193 245 39 205 190 160 17 228 78 132 80 116 159 11 210 139 69 104 163 14 210 118 211 134 109 46 211 188 244 142 30 28 200 217 104 126 18 115 108 13 227 161 192 105 57 19 227 145 82 214 54 33 10 58 80 120 143 169 220 213 247 71 80 95 72 248 107 154 64 105 39 50 26 98 224 6 181 160 238 208 115 38 110 253 159 232 217 66 188 100 209 207 50 229 37 231 221 154 3 111 196 231 34 158 193 65 236 210 78 14 198 122 160 226 63 36 44 4 33 38 73 183 251 141 170 238 81 87 55 192 208 161 178 74 105 206 50 79 198 144 214 234 1 149 255 227 246 248 150 158 25 235 117 5 165 102 97 36 48 53 237 242 112 7 182 230 59 213 203 58 191 215 85 114 102 98 160 145 153 239 26 132 179 167 89 205 134 196 105 197 167 188 103 44 212 233 152 113 84 72 102 20 104 143 163 199 118 61 96 143 9 239 7 253 161 43 37 127 37 80 220 223 119 97 113 71 208 198 172 37 117 26 170 155 142 104 33 15 148 199 178 2 42 122 38 89 22 14 116 217 189 164 214 84 154 43 205 9 48 16 104 121 54 90 215 184 7 191 249 151 28 96 131 20 123 177 11 137 191 216 97 26 46 54 61 14 11 119 25 62 231 70 32 63 175 137 172 223 208 232 94 158 252 237 70 192 191 31 125 97 199 119 138 123 140 9 29 168 120 181 48 158 213 3 233 152 105 132 165 108 133 119 131 80 18 55 50 102 68 179 91 173 12 80 202 179 242 56 182 13 111 198 59 242 49 118 174 154 109 97 230 64 229 176 26 162 4 105 254 90 117 97 62 157 167 19 28 151 202 101 67 119 255 79 8 211 32 72 201 158 234 148 20 191 94 96 245 214 157 159 140 135 135 225 42 77 82 111 235 197 43 88 87 100 223 67 122 161 59 80 244 113 251 155 213 205 109 38 95 222 97 254 21 156 76 199 9 189 39 220 179 241 142 51 63 178 130 101 233 219 134)
#f
())
#(66
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(132 77 173 193 143 27 212 184 191 205 32 107 14 178 22 58 58 198 78 95 218 188 129 209 112 88 253 151 251 92 136 58 246 11 235 182 245 164 46 13 191 2 205 102 211 188 108 70 120 127 88 21 73 189 34 23 109 142 155 117 238 224 193 15 100 5 42 245 171 60 2 221 100 250 135 97 59 89 41 57 0 252 93 46 215 21 214 160 34 221 209 87 36 73 35 57 114 166 179 155 124 128 239 64 141 208 131 228 246 159 254 26 194 231 236 88 21 61 220 82 116 60 10 76 170 159 88 189 244 75 76 246 137 11 252 153 219 129 119 2 187 68 99 122 136 241 59 169 36 8 213 49 69 214 147 151 12 232 17 84 18 77 166 189 136 205 150 215 49 208 242 72 247 101 84 204 219 52 173 244 31 255 179 201 156 102 14 190 76 229 1 171 150 173 82 209 132 128 46 212 166 104 35 212 75 3 116 3 72 65 228 72 89 9 167 199 200 136 224 23 66 208 79 133 191 159 171 211 159 223 250 203 169 233 123 59 108 252 62 39 187 37 48 115 146 117 243 205 2 202 11 76 192 165 185 72 85 70 186 184 193 1 81 27 61 127 30 243 53 50 123 16 182 24 205 123 244 10 4 62 208 46 230 103 213 226 50 119 239 244 181 212 251 81 201 42 130 253 206 16 228 18 224 49 0 194 102 124 8 79 84 243 118 155 33 220 246 250 199 40 239 71 252 183 243 253 245 43 98 67 193 85 22 47 166 58 131 47 220 75 72 230 80 205 241 126 136 125 13 55 120 96 97 197 38 58 127 97 233 102 165 70 88 78 69 75 97 210 174 11 83 101 186 63 189 255 71 57 171 56 140 8 40 131 236 201 56 86 130 199 76 48 87 117 90 201 12 188 172 125 194 150 247 149 34 74 144 43 186 148 40 251 172 92 241 151 211 106 218 25 74 34 28 198 179 109 154 147 236 80 141 190 185 171 199 64 204 115 96 35 197 41 131 0 240 221 59 246 237 240 219 65 122 244 71 39 128 126 226 96 32 211 60 238 236 73 239 231 81 103 27 192 107 95 77 162 112 107 202 122 9 22 68 93 17 119 119 37 137 95 116 26 62 45 19 115 73 244 48 121 168 159 4 159 120 182 128 194 233 203 91 219)
#f
())
#(67
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(199 234 76 241 222 219 118 22 122 140 150 247 228 35 70 130 44 103 133 201 75 224 86 208 174 243 145 140 137 194 67 217 166 74 222 248 167 244 47 115 106 25 195 104 140 142 229 208 19 188 99 63 238 6 150 64 141 40 195 139 149 72 217 152 103 123 50 137 199 205 128 97 117 30 10 123 237 76 28 231 77 133 246 103 21 235 49 151 79 40 100 14 130 25 11 221 199 4 141 200 79 116 123 203 143 116 243 86 119 83 218 114 232 136 226 156 109 186 110 251 244 253 135 148 13 60 112 112 100 252 231 230 0 211 131 24 221 28 116 43 21 64 2 161 100 238 190 30 87 65 143 48 41 47 97 186 75 44 75 222 118 105 154 15 15 6 154 179 148 156 42 151 17 102 54 198 162 22 3 214 232 164 25 9 155 203 25 234 236 63 141 106 192 199 108 91 149 18 247 160 150 34 151 170 99 30 86 74 237 206 77 65 243 100 133 243 17 46 45 220 8 20 92 11 2 168 112 103 236 223 110 37 111 112 163 75 72 48 101 201 209 93 194 148 209 231 55 44 75 244 89 145 160 239 146 71 209 76 141 224 172 171 147 234 11 135 137 43 16 63 184 193 130 48 2 201 119 167 211 144 179 163 211 146 198 123 114 206 236 106 247 43 159 80 13 201 32 80 50 122 40 107 139 157 240 154 104 24 108 3 166 250 216 33 1 132 165 81 246 242 84 92 248 101 98 217 120 232 166 242 170 105 126 5 156 31 55 24 23 105 5 139 167 177 153 21 15 22 94 218 174 0 248 90 81 103 12 46 247 158 43 244 232 196 204 12 191 197 180 48 183 99 32 94 47 32 139 70 11 59 112 174 80 78 8 181 35 124 137 11 188 115 18 230 24 35 174 212 182 153 138 190 207 8 53 246 186 183 198 251 215 41 20 63 131 60 30 92 188 235 218 167 234 213 181 161 53 177 110 236 169 37 92 206 152 152 63 58 156 237 250 122 1 209 194 253 23 145 114 165 108 214 97 182 66 181 46 242 106 81 233 143 149 124 140 244 205 150 188 171 123 33 106 72 38 126 102 27 182 172 179 40 69 77 55 108 211 162 54 123 212 112 105 178 218 160 26 188 62 69 220 163 73 113 13 209 116 202 85 235 231 71)
#f
())
#(68
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(25 114 141 40 195 211 171 57 93 71 132 101 119 121 146 68 70 159 225 149 181 151 48 168 30 123 195 224 36 22 168 106 73 109 99 77 112 77 10 89 219 232 101 169 32 144 185 227 126 58 90 10 118 161 130 22 245 100 30 238 42 26 142 88 162 93 60 150 80 13 178 130 251 228 118 117 139 205 11 174 153 135 50 51 46 66 239 209 192 109 179 211 208 220 220 99 250 137 85 192 108 123 203 250 150 130 114 212 201 246 24 210 207 33 26 21 107 25 101 106 207 239 252 135 73 131 143 189 187 176 51 214 86 11 178 223 138 7 249 157 183 241 143 133 15 210 138 165 216 157 27 222 189 96 253 186 31 139 96 68 201 70 171 14 83 162 57 228 73 103 76 91 152 54 213 245 163 169 235 31 250 200 203 91 10 135 20 168 254 46 21 182 233 136 179 113 228 52 184 40 145 231 137 109 231 82 33 100 38 224 118 155 17 235 89 200 38 133 109 240 88 153 38 84 219 108 244 232 153 154 212 197 125 103 188 245 5 253 211 184 67 210 218 240 252 17 1 109 100 197 84 177 119 19 255 131 140 160 62 197 137 110 230 242 111 144 250 214 60 212 79 120 187 113 126 189 44 131 155 101 95 197 173 240 231 128 24 197 235 252 148 34 187 126 252 102 158 77 215 171 28 48 109 50 140 209 142 105 209 106 134 182 63 11 131 46 8 20 73 128 194 225 215 168 201 102 54 212 244 144 127 54 89 89 175 91 86 4 64 129 146 209 19 17 25 159 70 141 222 205 215 30 128 208 232 111 49 243 109 243 87 109 192 130 62 232 42 11 202 171 98 175 255 84 130 1 240 84 247 251 194 39 44 61 195 71 54 62 91 15 215 134 88 219 92 145 71 90 207 125 2 164 37 172 83 205 239 161 48 226 104 103 105 218 247 66 208 94 6 247 157 3 32 97 116 51 224 244 137 128 207 9 53 68 37 217 99 52 167 36 193 163 98 142 95 228 55 180 134 17 59 197 221 247 10 217 51 34 5 126 124 250 199 115 255 241 52 89 30 81 51 193 143 205 73 213 186 5 60 224 33 202 19 116 74 183 100 179 12 2 51 84 109 103 180 59 194 83 239 191 236 53 249 125 136 28 62 76 56 252 69 40)
#f
())
#(69
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(186 111 225 153 178 40 125 248 99 62 137 177 167 243 141 101 16 146 210 251 189 246 205 246 216 82 89 5 87 73 123 254 115 26 233 156 113 177 69 234 0 155 108 209 115 19 206 212 6 240 24 143 119 58 78 139 240 227 81 222 202 197 108 12 229 130 186 25 36 210 211 5 202 62 177 241 10 216 124 134 155 194 50 168 63 214 170 77 156 164 171 34 184 61 197 150 79 157 196 161 81 0 50 188 64 156 3 126 35 103 238 90 127 109 173 240 46 84 19 127 224 78 132 70 140 66 74 5 14 114 40 72 197 148 211 236 89 50 88 66 171 31 250 15 162 92 16 114 81 230 216 98 51 229 212 62 157 108 194 187 48 6 188 27 92 213 52 23 162 62 26 136 0 69 153 90 190 44 108 232 229 75 202 206 228 119 230 201 158 4 188 55 64 177 187 170 36 98 23 119 11 85 62 236 25 198 30 50 103 249 219 158 104 174 138 46 242 22 194 83 166 104 144 83 152 224 115 221 255 98 7 90 122 167 174 149 48 229 136 244 12 24 172 41 78 29 92 23 113 153 120 135 226 125 47 7 210 14 167 105 137 205 18 120 80 21 206 229 25 78 45 181 251 115 108 37 130 207 208 72 99 22 255 61 63 38 241 154 52 138 241 71 183 124 246 205 198 38 74 56 118 26 194 112 194 236 93 133 119 133 171 197 58 58 93 109 138 5 35 99 102 24 14 183 223 8 118 82 151 179 132 168 226 103 153 75 132 119 81 178 83 152 103 20 83 170 178 119 14 29 210 68 141 18 133 224 120 174 90 86 27 210 51 160 236 250 42 74 146 100 161 50 190 184 62 170 181 222 92 41 217 176 210 170 205 59 18 82 121 232 19 54 112 15 43 168 231 110 117 111 68 17 196 247 108 250 117 128 98 46 168 111 171 3 90 205 165 223 250 96 219 254 169 223 43 3 185 84 10 27 137 7 101 89 207 86 6 170 150 152 122 91 156 70 3 149 147 114 107 108 25 199 5 21 219 33 118 8 23 251 245 136 205 21 155 123 197 104 3 241 194 117 83 63 181 158 73 19 174 43 121 115 167 219 240 52 213 139 105 72 164 145 11 93 190 104 139 42 46 72 53 77 25 37 158 223 245 92 73 82 116 18)
#f
())
#(70
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(130 201 154 187 183 229 79 35 79 242 242 100 93 66 103 186 128 244 180 204 126 101 165 39 2 241 247 53 187 170 216 134 28 61 87 5 45 141 165 28 71 142 40 99 210 232 6 249 235 186 238 118 98 93 7 190 76 73 160 253 110 63 140 86 241 134 164 61 153 75 173 115 235 9 204 199 188 62 205 71 208 93 239 190 69 181 97 92 250 162 99 10 29 160 73 247 0 15 79 195 152 202 26 150 156 157 235 226 188 36 79 126 202 146 55 74 61 87 121 77 90 27 119 39 183 74 154 195 224 52 55 36 230 226 60 195 100 87 149 187 70 78 80 88 136 186 1 168 123 8 150 89 114 78 82 164 253 48 142 208 69 34 84 57 94 236 118 204 117 155 11 53 43 181 72 31 114 31 220 33 212 205 49 84 141 17 195 21 65 98 143 245 141 105 120 203 15 140 160 101 155 83 49 34 41 231 156 23 24 59 114 122 96 244 130 221 138 254 123 33 34 84 223 228 37 207 84 196 138 173 81 92 237 205 14 17 132 237 117 127 125 93 249 250 118 100 241 220 43 149 13 229 87 175 10 122 192 103 130 72 126 64 232 91 40 100 201 188 232 19 78 162 206 97 18 23 60 205 222 224 49 189 83 189 182 52 145 213 150 212 59 139 23 103 1 143 221 178 103 3 240 229 216 79 173 115 200 248 246 250 179 130 52 172 96 169 108 11 106 18 97 155 149 112 245 68 145 207 134 255 124 0 252 4 20 230 191 242 186 12 29 121 236 66 222 124 191 90 50 55 200 144 221 102 38 186 111 11 148 236 228 125 97 109 167 105 182 102 112 207 14 120 118 6 144 62 238 153 247 79 48 212 83 238 15 3 165 213 251 225 107 31 73 84 227 122 240 120 128 231 121 169 19 172 160 74 8 78 35 79 236 169 150 54 42 98 103 48 75 33 51 97 159 145 161 205 93 188 135 50 15 70 251 61 19 99 126 170 222 68 132 111 166 220 234 184 174 140 245 145 169 17 159 229 12 255 97 239 120 157 194 179 253 121 150 232 45 8 70 165 219 109 205 12 250 185 107 255 29 190 20 4 123 33 58 214 218 130 41 205 40 31 71 171 236 92 30 178 66 56 238 241 0 103 112 229 115 15 242 112 209 104)
#f
())
#(71
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(167 53 246 97 97 62 120 104 76 206 228 54 228 157 120 175 65 168 156 50 90 93 44 200 254 253 115 76 118 147 138 218 9 255 142 186 163 187 177 243 85 70 251 167 110 116 120 32 118 213 108 218 154 67 54 60 62 197 139 219 18 24 58 186 165 197 15 90 227 55 234 83 175 45 255 17 72 174 135 130 84 97 210 148 254 67 55 17 201 137 16 17 246 75 36 51 166 67 238 133 13 34 39 229 154 19 34 163 24 234 102 227 81 106 138 88 68 239 135 252 78 217 97 235 85 193 70 182 249 138 56 148 85 185 115 4 21 130 131 204 240 61 245 36 113 226 93 53 169 196 105 62 181 30 50 108 160 162 174 113 154 249 51 136 17 147 101 221 6 206 13 148 42 129 8 149 225 237 4 39 150 1 72 166 249 233 214 81 115 147 52 130 209 186 187 191 194 243 5 61 110 173 39 69 41 37 74 105 169 3 215 242 209 95 227 163 71 233 231 55 252 250 247 36 183 167 204 33 208 32 72 218 192 224 96 122 167 246 167 168 229 222 78 219 47 129 194 92 121 115 246 50 191 213 34 218 215 142 182 198 40 119 94 18 72 79 199 45 151 230 188 53 184 218 246 143 72 69 101 55 104 39 151 203 102 212 37 45 1 199 152 96 110 68 1 66 242 88 89 196 222 194 233 22 179 240 6 193 76 50 154 214 126 111 228 241 59 176 82 33 69 173 21 131 170 73 35 156 197 150 207 39 108 162 229 137 78 68 130 117 164 116 201 53 61 46 126 112 149 205 170 28 238 80 217 103 228 89 176 97 157 94 72 227 44 50 142 1 72 56 30 163 244 181 168 175 191 62 51 171 88 185 130 9 213 254 21 44 244 58 240 66 239 213 218 180 34 67 128 230 242 9 241 81 100 34 144 81 58 255 182 57 97 134 79 53 172 133 238 172 203 136 4 218 106 16 171 168 94 218 84 56 249 170 24 79 150 65 42 14 32 91 107 139 175 85 46 14 137 163 56 202 207 133 234 188 57 10 247 69 105 76 81 226 108 135 124 208 201 192 227 143 131 67 98 25 234 191 157 210 59 229 96 74 6 194 65 26 8 222 199 225 92 198 234 169 152 153 197 108 140 159 193 81 184 56 185 152 232 174 190 88)
#f
())
#(72
"including undefined tags"
#vu8(49 50 51 52 48 48)
#vu8(13 125 132 206 195 184 151 112 56 80 215 112 130 107 26 198 247 78 216 125 76 81 57 161 18 26 238 171 32 186 10 216 52 71 215 231 103 242 57 78 245 184 178 140 196 49 202 144 122 182 77 87 217 65 144 40 71 28 174 141 108 109 215 106 208 49 240 107 70 45 68 243 200 32 82 130 91 251 196 146 78 49 239 90 137 22 109 144 64 46 8 42 1 174 40 157 90 146 182 106 178 106 157 173 95 39 157 211 150 148 242 145 246 17 58 187 147 55 239 223 172 203 138 148 203 73 190 209 142 42 121 134 88 130 210 64 116 189 9 106 53 37 166 96 110 208 10 51 120 248 103 162 172 46 129 196 48 61 89 168 56 113 231 125 64 152 248 250 253 191 45 185 160 224 0 6 233 48 93 221 191 151 116 212 197 95 249 37 18 125 247 33 103 154 13 112 26 235 142 152 123 110 6 24 116 181 164 138 49 90 55 88 211 152 239 38 95 215 161 77 118 203 200 162 104 27 187 63 60 195 239 125 237 55 249 155 249 134 34 5 179 51 214 68 148 93 255 80 252 107 32 40 139 39 89 26 32 74 65 93 121 201 193 225 160 136 249 35 78 220 78 203 228 158 121 81 224 131 80 202 100 22 61 39 216 56 67 49 131 8 111 143 84 146 215 164 199 224 24 0 110 130 97 13 215 252 155 116 68 25 211 188 167 104 112 149 51 231 10 215 113 137 167 25 15 93 29 226 229 94 49 230 142 254 55 36 35 155 97 220 129 20 6 11 105 160 239 42 114 14 238 8 22 41 1 176 90 0 80 54 117 40 68 202 160 43 105 83 126 251 242 77 197 34 1 12 126 181 58 249 110 232 189 176 51 103 142 201 104 41 244 251 195 60 148 17 44 135 217 69 235 220 51 52 245 176 252 179 153 179 115 63 222 199 110 196 193 216 123 87 6 235 130 148 239 63 6 135 122 51 243 17 213 83 49 128 173 218 229 99 197 127 201 57 203 121 20 4 235 160 100 200 240 0 152 40 235 35 21 180 108 38 109 115 82 197 99 164 29 111 240 56 37 140 148 181 26 113 9 133 174 103 143 186 10 71 49 212 48 59 85 48 133 22 45 53 68 12 69 62 178 35 210 216 205 181 140 212 195 72 101 93)
#f
())
#(73
"truncated length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(103 62 50 77 124 210 73 189 223 212 204 15 236 251 197 159 201 37 40 56 96 69 194 200 223 58 176 103 62 99 29 103 90 50 23 82 19 78 48 148 126 215 213 205 33 36 178 135 15 135 119 195 46 247 229 232 199 107 81 210 98 172 210 224 179 9 4 20 9 121 238 24 220 93 110 126 61 78 151 187 117 130 90 218 86 49 161 3 110 138 237 251 25 77 226 174 254 254 56 130 124 19 213 40 117 45 83 55 167 82 211 147 140 203 73 39 147 201 158 122 114 102 131 171 125 205 159 203 227 253 210 144 143 255 172 109 134 107 19 201 97 125 39 43 22 179 92 115 186 250 16 187 203 33 111 68 165 67 169 199 94 136 172 133 224 108 69 205 205 252 43 12 187 144 13 171 193 29 224 54 254 34 234 6 211 59 248 68 209 55 22 129 194 165 17 225 200 164 117 222 189 7 1 198 123 109 221 144 120 24 195 0 243 47 237 52 26 196 252 215 163 86 211 5 66 207 9 107 243 105 220 149 227 91 89 174 242 167 192 163 185 30 126 212 38 126 5 147 152 226 130 202 164 13 76 253 64 112 1 175 46 133 199 129 153 206 144 101 148 77 142 255 203 26 51 14 165 207 92 202 202 159 196 72 217 103 172 62 123 251 225 242 73 151 0 170 253 34 47 231 67 55 124 201 19 2 35 94 100 70 205 205 232 34 171 68 29 7 74 219 209 117 19 91 7 119 88 141 90 8 198 228 167 82 244 107 126 29 36 181 23 158 252 60 14 18 6 133 103 181 193 135 211 39 164 77 233 248 207 45 67 70 163 9 191 145 153 95 170 209 250 123 98 39 6 101 191 201 215 171 78 94 10 11 248 216 105 1 229 201 4 23 15 188 129 141 45 182 127 122 52 27 207 68 161 59 6 61 83 200 31 215 247 197 184 58 210 85 78 94 98 75 110 219 112 141 11 241 160 180 91 12 154 8 123 199 17 218 179 1 134 21 181 244 29 22 67 48 213 249 93 175 230 123 196 130 220 65 131 231 13 62 22 164 228 212 56 167 40 130 93 48 131 30 185 95 89 204 101 100 155 78 232 156 1 219 76 1 61 150 38 91 200 90 85 238 98 251 51 96 228 203 192 142 157 209 152 104 64 232 172 211)
#f
())
#(74
"truncated length of sequence"
#vu8(49 50 51 52 48 48)
#vu8(176 18 32 198 125 221 72 226 4 231 121 148 255 174 61 111 150 121 15 87 131 123 20 29 238 206 70 18 2 232 159 21 164 72 121 144 228 245 167 3 193 178 65 16 170 232 122 131 120 183 188 91 200 137 109 81 223 45 16 2 14 211 163 163 236 116 209 125 180 2 76 43 35 183 183 219 149 139 79 131 115 205 56 0 242 172 218 88 72 199 216 171 22 62 84 212 147 54 250 188 108 59 93 25 10 143 199 134 20 180 184 171 18 221 167 132 110 64 148 178 141 236 248 254 145 246 246 19 62 44 16 198 168 194 115 56 248 32 65 103 69 210 190 146 29 146 177 236 85 122 64 226 21 59 251 111 57 226 237 76 70 46 141 108 234 81 8 167 21 168 87 195 224 203 233 5 182 201 199 24 88 169 42 170 213 220 142 227 65 35 168 165 143 237 146 237 252 104 5 58 212 146 210 145 151 96 25 148 191 142 221 125 31 31 134 18 63 14 197 95 139 141 21 225 224 169 253 215 133 67 241 106 123 121 164 141 217 71 100 102 213 125 47 11 244 62 164 161 83 192 147 226 20 78 83 226 251 166 196 20 21 197 244 11 138 3 46 117 57 149 186 147 8 46 102 171 17 225 224 19 33 166 111 207 101 175 45 39 4 68 244 143 30 84 241 75 178 113 244 165 210 6 70 154 209 252 198 210 65 109 152 156 138 66 197 244 42 189 82 90 236 151 54 186 185 25 171 93 213 188 99 20 230 77 76 7 112 185 99 66 93 208 33 249 13 144 67 25 35 38 151 66 80 186 134 191 54 44 86 106 112 18 7 128 135 218 216 196 161 123 129 70 105 133 186 165 26 48 107 246 117 227 72 194 77 39 217 10 86 174 203 231 39 109 33 79 8 131 19 52 13 207 207 94 95 68 0 214 243 255 193 73 124 62 234 9 235 189 119 237 140 250 234 130 118 79 47 148 120 113 90 250 115 123 7 154 170 3 207 179 222 230 238 111 210 25 209 223 73 212 200 199 181 127 36 200 137 152 4 174 169 241 193 163 121 97 108 4 171 75 88 16 84 60 69 243 11 161 166 96 241 50 92 221 133 146 6 155 149 25 111 189 199 156 50 218 121 118 237 57 157 220 73 72 192 203 25 148 210 200 241 9)
#f
())
#(75
"using composition with indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(9 34 160 45 56 178 84 207 193 176 41 101 190 77 179 182 219 19 122 63 204 116 20 115 126 227 75 26 32 76 87 94 225 42 104 96 232 77 143 32 77 188 103 198 97 62 117 173 232 69 3 100 192 92 215 148 86 65 220 146 15 73 249 46 10 172 181 157 4 215 227 2 218 111 3 0 9 48 86 116 207 215 36 148 110 245 191 102 23 99 88 90 221 199 8 24 118 252 78 251 219 186 223 213 215 122 101 34 27 254 41 96 179 199 244 56 66 84 76 201 127 55 16 239 144 206 80 128 150 146 26 46 44 50 205 85 152 59 38 133 178 245 253 215 192 218 90 34 147 171 110 125 71 166 19 1 34 44 64 245 214 75 198 99 134 254 189 55 195 117 239 210 238 142 67 171 230 138 251 52 255 46 161 35 110 63 29 1 149 150 37 174 224 224 95 164 15 149 88 60 69 83 34 248 204 247 219 255 128 213 33 43 216 207 188 84 161 44 182 166 137 248 244 235 73 119 252 91 219 40 124 224 47 124 90 113 74 188 205 245 14 253 46 83 2 168 158 86 84 153 63 160 159 245 228 80 134 218 206 88 234 188 15 7 140 226 252 231 36 187 201 107 109 227 106 217 208 229 196 153 63 44 47 196 22 234 25 107 147 172 99 97 159 94 171 112 119 119 163 118 216 208 165 29 121 165 197 134 180 70 154 84 190 255 168 254 86 176 235 250 186 87 155 71 132 72 89 32 46 95 248 188 200 102 14 19 44 55 228 108 63 232 1 170 97 77 80 201 149 48 37 179 56 220 77 140 194 221 235 193 208 119 69 167 206 192 27 217 65 77 130 137 42 63 72 24 198 52 213 28 72 107 112 101 40 142 87 174 157 21 32 207 2 195 151 204 2 150 198 116 170 5 207 103 23 96 242 240 24 182 220 184 219 115 247 159 110 149 234 33 17 192 100 91 230 73 39 201 248 2 248 39 121 34 189 249 74 107 221 112 35 83 18 71 186 170 201 90 177 13 127 203 252 131 84 187 68 97 106 133 154 131 251 8 15 248 149 82 128 118 165 195 40 248 149 22 230 38 148 178 128 54 0 48 93 16 168 81 60 247 5 134 111 69 159 54 47 118 78 236 112 111 119 179 37 189 124 212 2 85 254 8)
#f
())
#(76
"using composition with indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(206 253 207 57 144 45 0 62 24 216 2 254 96 105 3 158 198 94 22 163 209 78 142 129 213 215 24 125 178 234 224 74 54 179 99 106 14 12 235 55 67 155 162 27 13 193 39 174 87 200 208 117 87 209 105 3 174 51 209 179 82 59 243 185 60 101 224 121 229 221 125 61 111 70 127 140 6 94 218 222 119 4 182 44 58 77 66 44 209 76 14 23 34 0 56 177 223 14 3 149 66 117 139 66 166 6 3 65 20 148 173 202 15 227 87 163 61 20 12 46 83 164 59 117 108 10 36 68 97 128 68 251 210 177 132 75 190 11 172 89 191 16 229 39 226 185 105 72 135 19 90 41 221 236 28 104 175 104 21 71 243 143 178 3 188 222 79 139 12 173 177 147 15 182 62 52 64 103 234 28 16 79 113 86 44 85 197 162 253 219 27 171 199 240 222 12 60 40 163 41 49 208 151 15 110 66 170 226 16 83 50 224 74 54 195 185 97 139 202 10 145 153 156 66 110 50 194 106 18 119 251 19 56 223 27 25 68 120 210 250 48 223 253 161 5 0 122 70 27 149 76 27 139 191 132 59 54 150 74 188 33 230 180 59 237 0 14 25 117 48 96 247 149 185 188 31 35 138 89 50 138 36 231 203 59 172 159 26 79 221 223 1 87 125 139 139 169 37 35 251 204 38 227 250 188 157 209 126 249 80 209 13 97 131 42 38 154 9 161 205 81 35 235 118 196 190 104 11 99 61 15 108 213 141 135 131 58 170 181 66 188 195 128 151 21 97 165 168 216 42 73 219 178 78 72 206 95 144 248 74 251 42 200 163 43 142 96 96 70 80 36 125 240 170 156 142 106 237 219 132 181 84 70 251 131 52 186 171 164 176 136 132 215 219 32 196 171 193 253 129 156 193 163 155 31 230 61 122 116 210 114 235 74 229 174 37 166 216 84 254 254 13 8 149 53 164 195 204 224 45 36 125 216 31 21 4 201 131 216 118 95 61 250 27 23 120 210 197 215 217 13 209 179 171 7 221 27 178 24 65 191 254 234 242 190 179 35 64 58 124 191 238 159 79 201 232 61 63 144 175 16 14 164 248 146 98 99 85 187 108 10 155 20 198 147 124 213 151 75 149 26 253 114 33 84 95 29 74 182 207 113 14)
#f
())
#(77
"using composition with indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(199 187 106 138 205 187 35 124 128 214 151 174 6 81 60 76 191 204 109 130 52 64 235 66 81 154 41 251 23 167 167 26 2 168 240 127 144 119 5 122 178 233 102 73 51 208 177 144 89 113 237 13 135 70 177 31 112 54 202 125 111 198 50 137 17 52 44 101 65 39 22 49 110 97 36 208 116 182 165 156 46 92 67 244 211 209 102 59 181 56 130 148 11 52 187 52 251 184 113 224 213 107 203 89 0 105 230 251 222 244 96 19 49 174 19 246 211 164 174 202 154 210 20 60 104 228 106 247 212 17 77 72 169 179 52 82 224 114 190 122 136 24 143 114 149 37 233 199 47 128 68 2 250 96 112 178 77 76 44 216 123 73 128 49 170 135 144 158 231 61 83 211 236 192 126 158 71 102 244 93 207 143 2 255 178 137 255 110 21 7 233 19 229 90 157 104 188 140 53 88 155 6 101 236 73 130 55 52 21 151 248 91 29 62 142 124 118 75 167 218 1 144 31 144 233 238 245 74 231 47 49 158 209 122 96 140 37 109 120 166 21 193 108 212 48 217 74 245 192 216 151 119 22 107 4 141 82 253 84 248 27 84 131 88 177 186 148 214 93 103 117 153 221 215 195 183 79 16 2 178 208 132 51 71 19 163 158 181 73 159 93 81 99 170 47 86 202 215 215 225 139 196 46 225 237 204 118 217 33 137 111 15 247 179 176 105 6 183 208 116 170 199 48 144 149 4 177 6 120 168 62 173 113 28 220 76 152 71 72 34 142 205 111 146 114 154 189 0 14 56 225 117 94 241 89 171 0 1 171 187 138 242 3 21 206 16 250 227 157 146 210 182 146 230 251 122 46 34 0 114 43 248 113 91 106 58 11 244 168 49 43 1 194 10 161 175 251 188 212 156 207 125 99 18 197 238 63 221 68 61 194 183 99 156 65 116 136 198 55 34 207 2 113 4 50 198 35 133 69 4 238 11 110 17 131 188 60 148 8 118 213 143 58 80 122 48 108 0 24 152 47 28 177 99 12 151 198 73 187 100 94 243 209 184 117 24 148 55 218 39 15 37 240 181 229 252 209 87 106 212 207 56 113 11 222 245 240 145 49 191 227 92 130 170 12 132 30 9 161 72 55 165 219 114 138 31 55 114 131 249 82 98)
#f
())
#(78
"using composition with indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(171 157 211 179 23 123 143 159 228 155 246 147 183 214 235 133 98 250 46 13 4 144 93 229 187 45 140 39 201 80 74 242 12 201 0 82 224 65 136 6 53 244 84 4 87 23 119 158 189 35 89 160 210 92 93 35 127 82 121 218 244 109 1 111 219 163 125 39 22 34 21 139 107 31 125 239 160 142 206 224 22 32 176 182 227 152 254 172 11 58 20 184 78 190 0 74 32 99 216 36 143 150 20 179 164 105 196 38 246 141 243 142 17 194 157 136 86 63 167 145 96 74 222 196 22 183 113 236 254 198 212 199 18 91 26 26 76 54 166 23 191 180 111 241 22 37 145 74 9 214 231 43 65 26 53 223 215 184 5 121 58 215 69 136 146 247 132 125 95 141 1 133 40 90 234 39 250 67 2 3 52 232 181 201 112 240 172 48 106 188 195 59 23 155 42 28 34 50 37 67 255 241 180 3 24 22 182 47 100 132 144 249 108 134 88 117 43 150 225 43 34 36 136 224 230 189 177 112 200 61 38 151 192 233 121 49 194 104 149 201 87 73 152 214 122 44 154 47 231 48 158 73 138 34 172 199 151 117 9 226 167 196 71 100 209 10 193 240 242 105 129 43 15 175 152 39 61 169 153 150 224 209 104 22 171 51 195 198 162 220 130 9 171 57 254 95 224 177 33 196 224 123 62 59 204 94 47 220 70 208 28 172 125 193 201 190 143 75 31 180 67 78 166 61 32 67 19 16 27 1 172 162 246 71 157 36 172 41 55 193 248 10 35 29 229 162 99 249 250 165 195 108 30 10 243 128 197 80 96 106 146 176 182 50 188 72 109 197 212 150 197 156 50 102 93 19 216 193 155 45 205 42 246 175 252 124 174 3 247 223 85 71 250 214 55 113 2 49 20 254 142 104 98 139 27 172 129 35 26 53 155 10 39 186 134 245 238 7 232 161 246 140 118 169 134 44 190 195 129 80 192 44 108 208 24 5 217 13 36 158 240 246 97 110 204 169 232 68 253 156 156 16 244 149 37 52 233 95 11 208 171 246 106 36 166 39 109 186 51 43 196 223 241 158 23 96 29 168 0 123 187 43 14 209 228 81 123 33 17 231 81 80 100 97 168 82 113 183 101 29 137 29 48 62 173 162 41 163 17 38 115 17)
#f
())
#(79
"using composition with indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(198 141 120 215 16 170 121 52 244 234 109 190 160 229 14 169 159 171 210 236 245 191 189 81 151 74 238 128 197 116 80 159 43 222 149 45 69 128 184 254 204 167 138 16 52 170 139 72 61 252 106 122 68 19 204 113 196 248 54 247 101 251 134 104 110 230 143 70 207 14 178 25 31 158 136 123 147 5 68 211 252 242 13 152 162 236 41 182 82 235 119 239 109 153 77 188 157 43 219 14 144 27 91 182 170 196 156 206 218 199 112 171 26 122 63 185 94 51 240 181 244 34 133 136 108 82 166 81 150 6 31 83 163 8 205 67 224 137 250 157 23 209 74 94 160 252 195 157 216 55 170 252 111 85 108 59 90 255 247 45 118 216 167 7 230 118 104 65 186 167 86 64 205 192 217 232 192 176 27 141 31 10 58 103 217 27 193 47 197 0 243 160 252 177 195 52 46 39 166 255 72 222 162 79 36 202 206 84 148 175 207 51 130 217 80 39 154 7 209 117 187 16 249 66 250 87 211 162 141 91 254 169 6 242 49 27 100 50 1 42 66 236 37 153 127 243 83 150 199 110 72 118 125 111 13 0 99 176 114 34 222 151 241 97 154 184 244 71 31 9 38 148 239 124 56 34 172 136 32 107 63 73 27 192 203 146 163 67 189 41 18 174 84 183 67 48 206 142 235 31 39 73 201 157 243 6 103 248 199 179 158 124 98 61 12 18 170 231 143 235 142 212 117 120 243 71 235 158 109 158 51 13 232 193 242 151 69 178 62 101 116 3 54 127 252 80 100 214 182 40 51 163 148 79 79 126 65 255 130 248 164 154 63 8 57 94 90 129 1 184 54 33 188 71 154 32 130 54 166 195 39 49 32 108 83 99 153 125 91 18 239 165 79 199 148 109 28 193 198 235 76 149 81 131 217 235 192 225 109 196 191 209 193 23 1 252 152 124 90 187 17 164 143 229 199 134 50 90 115 150 248 138 21 95 149 160 71 144 89 9 39 132 109 22 166 37 116 210 197 243 199 22 253 73 102 217 221 77 156 144 1 155 134 75 35 200 23 148 72 41 64 64 5 1 178 36 186 159 78 97 246 144 237 162 179 53 155 26 36 198 56 22 195 182 93 82 116 226 27 226 199 72 42 25 134 81 104 188 44 193 204 11)
#f
())
#(80
"using composition with wrong tag"
#vu8(49 50 51 52 48 48)
#vu8(137 65 144 85 129 87 225 146 73 97 23 95 180 12 125 147 123 144 135 235 235 243 143 68 86 150 14 173 148 81 135 171 54 146 167 153 14 81 48 37 119 96 52 135 41 142 199 80 68 171 165 153 212 111 248 221 127 151 48 15 135 151 218 100 77 210 248 41 158 62 65 147 228 60 65 25 122 154 195 188 200 234 212 113 58 24 156 126 186 201 98 178 228 163 140 133 202 148 116 57 152 230 176 120 249 54 185 165 62 194 241 175 239 112 223 125 249 106 106 64 208 60 209 50 24 184 132 244 6 11 242 171 228 101 219 62 126 202 190 145 8 251 77 169 135 241 152 59 192 247 158 42 47 223 134 238 130 114 197 184 8 123 181 149 22 140 30 165 157 50 234 58 101 56 185 177 58 206 8 171 9 247 91 78 183 199 170 107 35 220 75 171 49 138 197 139 1 117 135 153 227 69 157 179 193 153 100 198 118 213 13 59 129 150 251 250 205 198 40 214 229 52 6 30 214 225 74 123 13 65 201 133 105 102 223 156 116 242 174 130 222 172 113 72 169 247 134 121 126 244 206 190 198 212 49 162 225 36 7 39 167 147 136 45 211 33 62 221 79 34 177 249 74 254 166 251 164 188 253 180 180 27 77 61 196 100 0 203 55 191 230 29 66 54 197 24 219 75 224 82 114 14 119 67 81 199 251 44 199 190 237 25 46 40 165 109 51 83 99 46 164 200 7 246 136 179 104 102 13 181 123 146 175 222 93 239 166 28 76 188 155 106 209 251 1 43 19 179 77 84 80 101 228 72 198 20 131 91 75 248 128 66 3 158 181 239 60 251 233 51 97 98 134 53 133 76 55 72 116 104 232 47 148 110 1 218 120 195 100 143 4 250 144 55 4 153 106 107 143 235 152 166 209 163 147 219 66 68 59 190 175 38 109 79 174 26 178 196 28 249 233 116 3 158 74 171 224 40 228 10 203 75 232 156 109 124 216 190 123 79 79 247 67 225 43 158 59 41 236 75 21 8 160 89 6 76 147 2 13 43 141 202 138 84 136 223 66 25 210 233 29 181 84 44 167 72 54 9 171 142 136 28 32 46 211 164 138 166 89 108 127 98 203 115 201 240 196 51 245 99 228 154 188 239 237 92 2 227 7 149 74 125)
#f
())
#(81
"using composition with wrong tag"
#vu8(49 50 51 52 48 48)
#vu8(43 224 162 234 67 184 163 160 86 132 17 215 154 115 170 41 231 79 62 122 184 141 142 71 66 107 190 107 108 135 48 180 101 240 23 251 137 119 202 241 203 137 131 0 205 134 204 135 61 81 66 83 252 175 35 152 152 13 137 133 18 21 220 231 246 27 49 6 250 255 113 101 91 33 142 37 40 137 122 69 22 1 67 55 220 212 8 103 172 129 236 192 171 4 151 144 131 150 35 127 50 101 190 6 192 5 177 16 182 238 182 157 234 12 20 88 237 228 254 139 145 97 66 119 35 240 96 63 138 25 203 144 162 33 197 238 159 134 143 74 210 159 230 71 33 226 2 171 57 133 246 217 58 239 199 151 83 128 38 10 208 175 46 119 251 185 234 76 67 38 227 19 7 135 152 80 208 22 238 18 178 57 209 252 250 66 56 61 211 229 172 76 17 232 170 243 252 140 123 80 198 80 235 203 188 238 65 200 35 38 131 12 71 62 113 141 190 88 173 178 11 90 233 55 76 207 58 217 238 250 169 224 21 130 158 206 73 143 88 39 50 98 134 226 244 192 126 165 220 118 24 216 229 110 79 9 240 191 165 60 214 137 95 61 106 55 135 31 206 234 170 233 173 137 150 0 122 131 168 255 7 7 24 233 1 79 198 28 76 185 164 217 205 118 43 79 29 241 136 61 230 239 202 221 104 73 160 189 191 48 149 244 40 31 254 204 39 139 32 229 106 151 141 35 226 210 176 240 255 146 157 212 225 31 15 147 71 159 158 9 251 207 197 11 195 238 52 87 132 237 147 84 239 29 195 132 49 109 90 144 26 135 209 65 35 141 204 37 233 15 115 155 194 208 246 28 181 130 154 111 178 152 208 21 39 114 111 253 99 3 15 207 174 209 32 241 120 54 209 193 23 127 109 197 241 11 34 141 56 163 189 59 188 153 127 51 146 80 121 228 33 226 177 233 4 255 52 51 127 8 123 96 155 98 246 206 76 196 132 210 188 173 149 61 116 54 180 189 15 34 3 97 80 190 4 238 117 190 215 238 197 201 242 130 221 104 96 55 23 139 108 81 116 2 67 24 9 214 13 179 235 105 252 174 15 148 145 49 24 60 181 50 54 79 226 165 77 235 86 99 7 6 102 166 145 59 162 221 247 173 112 7)
#f
())
#(82
"using composition with wrong tag"
#vu8(49 50 51 52 48 48)
#vu8(218 237 109 7 124 160 212 114 87 151 116 125 11 173 142 97 123 36 196 214 188 34 214 214 116 58 1 224 184 249 230 137 201 37 103 177 62 104 19 146 53 224 240 117 154 122 212 238 150 123 72 40 40 248 92 218 172 217 7 8 80 206 218 253 43 47 211 63 28 90 255 220 130 97 9 224 191 104 160 248 182 85 89 156 87 134 80 50 102 116 186 37 112 171 255 14 207 236 55 189 19 63 183 149 204 204 131 22 43 184 74 169 63 164 201 40 169 67 219 81 247 238 48 197 0 46 146 184 239 174 71 108 85 86 5 114 162 244 122 123 160 76 159 133 1 132 2 164 173 140 242 178 19 136 165 39 109 154 49 175 166 211 224 248 94 69 64 108 84 223 206 205 30 1 232 255 110 15 18 242 59 149 205 227 135 195 235 246 168 106 158 173 118 49 215 117 163 152 128 34 81 7 205 255 84 156 168 170 84 116 136 92 33 163 219 33 41 3 107 71 74 191 208 171 204 19 77 8 102 192 94 4 61 22 212 158 234 1 9 182 33 197 31 212 65 133 0 19 203 45 23 165 48 47 98 100 110 254 45 211 131 244 70 78 204 247 39 178 143 131 162 219 191 143 235 232 71 46 170 151 95 109 195 79 130 87 26 94 78 31 33 214 93 25 102 74 236 105 76 31 84 219 238 217 189 61 104 85 177 152 146 180 169 210 220 78 84 69 29 40 102 49 23 112 187 45 61 166 224 145 174 131 204 38 31 161 74 113 5 17 193 3 234 194 250 123 192 108 107 28 4 129 51 209 71 157 50 62 199 154 223 133 144 138 129 241 6 162 4 112 238 211 209 214 11 135 80 165 8 216 218 23 22 74 149 42 23 10 47 42 173 189 246 17 234 49 43 37 217 63 161 14 32 46 163 14 223 143 88 76 62 189 61 113 19 213 228 174 97 138 99 117 91 113 3 229 245 136 126 216 211 59 234 40 123 23 22 46 100 151 174 202 54 50 7 107 129 225 127 160 53 151 249 51 111 39 148 146 137 155 143 4 37 90 154 141 189 58 223 182 236 23 173 179 5 221 15 199 162 20 64 41 99 52 43 51 191 30 174 152 245 189 188 15 247 202 63 107 148 202 179 233 60 248 175 100 211 157 41 78 198 192)
#f
())
#(83
"using composition with wrong tag"
#vu8(49 50 51 52 48 48)
#vu8(119 210 189 47 85 179 124 214 129 32 56 205 130 133 183 230 223 180 145 197 43 101 167 243 70 91 53 161 152 205 182 148 212 78 141 102 19 249 6 28 245 204 188 108 134 22 49 124 171 120 201 74 101 96 225 246 76 37 219 174 37 154 71 183 83 217 177 249 92 98 114 4 98 4 61 220 106 19 144 253 169 225 81 132 139 250 218 127 116 245 35 169 231 41 218 245 8 242 5 57 119 247 63 207 26 151 221 92 34 124 92 252 3 89 94 248 43 54 169 155 229 8 145 170 161 213 22 238 162 156 9 76 78 238 24 214 30 154 83 226 0 182 253 170 78 72 214 217 84 233 214 85 127 139 65 84 236 225 156 116 92 227 72 188 88 134 170 117 247 83 8 106 28 198 19 184 179 189 141 242 9 117 26 166 215 215 173 20 30 235 25 70 58 68 216 54 227 107 27 136 178 44 186 224 141 135 167 19 216 48 140 154 249 102 121 18 41 134 162 65 28 173 144 212 145 155 227 40 72 87 162 151 195 250 79 169 80 186 11 116 233 191 133 112 23 27 189 1 103 42 90 10 214 228 101 9 10 183 79 230 207 125 125 158 166 197 226 246 33 213 46 134 182 150 114 232 189 218 23 79 79 30 254 116 95 4 10 178 116 91 224 98 84 220 148 217 32 34 236 216 159 234 196 143 227 235 24 19 56 191 103 157 247 192 107 140 109 214 232 186 219 114 8 198 9 225 94 198 227 140 190 204 207 36 146 185 37 210 69 202 193 229 3 118 128 24 103 210 41 248 251 146 212 154 152 146 100 91 109 117 100 100 115 97 173 4 120 116 248 92 32 46 98 65 40 235 222 166 233 103 148 244 233 65 145 128 21 222 211 185 183 86 101 56 240 87 189 211 136 102 23 111 0 75 54 57 246 128 246 49 149 161 142 128 32 224 66 100 47 239 172 62 221 69 162 231 70 40 11 205 24 14 84 234 78 140 156 125 25 106 145 157 13 177 211 13 61 83 57 116 125 186 21 43 174 92 182 235 123 83 184 95 0 184 114 15 109 77 226 16 149 55 128 76 27 29 101 41 59 56 92 141 151 102 12 27 155 132 196 110 221 238 29 45 151 184 16 135 158 249 92 30 131 238 37 5 116 169 130 54 57 216)
#f
())
#(84
"using composition with wrong tag"
#vu8(49 50 51 52 48 48)
#vu8(20 25 33 177 193 177 223 212 76 170 181 185 67 155 207 18 241 165 199 250 39 61 164 158 123 168 185 170 108 255 184 71 72 23 167 253 121 144 34 199 98 222 250 24 188 100 231 4 170 61 239 212 77 224 172 151 131 63 31 202 232 165 43 88 249 204 219 147 188 58 166 129 50 88 67 1 133 37 52 170 183 91 242 218 61 160 127 74 188 70 216 89 30 187 185 253 31 130 111 213 90 154 155 206 85 200 151 222 223 64 55 158 194 137 184 60 226 132 44 89 83 54 93 223 67 176 156 157 89 220 112 232 85 43 163 77 87 200 164 206 16 140 40 187 98 130 67 155 224 16 33 28 99 121 128 174 179 11 184 192 29 155 8 57 205 133 225 163 100 47 60 205 164 4 12 182 3 125 226 245 156 191 10 241 95 172 66 12 160 57 53 137 210 215 115 54 220 8 168 98 85 164 185 153 158 45 185 25 95 243 237 121 203 128 201 236 218 227 128 214 132 220 7 238 31 186 250 151 125 210 72 227 66 193 44 4 128 141 47 200 157 172 222 132 183 1 54 70 113 245 164 73 82 89 141 44 111 208 228 93 83 176 229 24 241 218 190 52 112 27 105 39 146 83 217 155 141 186 103 152 239 35 100 138 6 196 191 8 184 6 26 149 110 203 170 234 251 109 246 211 32 172 183 27 106 192 166 161 4 98 79 31 84 102 77 104 142 24 83 49 110 0 14 40 226 126 95 36 128 133 177 114 101 251 202 196 49 27 39 185 7 86 238 187 58 128 1 217 32 192 134 245 23 194 174 191 204 106 112 184 155 145 48 216 38 185 39 170 17 157 209 10 21 222 140 144 21 110 252 125 248 246 132 89 123 98 202 156 121 134 154 81 87 235 235 116 214 111 111 166 201 45 171 235 225 141 101 37 72 174 149 28 139 166 89 149 107 38 59 194 176 140 237 80 23 110 90 75 44 242 101 168 21 17 82 159 150 19 56 7 143 223 6 82 25 77 164 174 81 205 40 72 12 149 46 231 114 45 4 197 214 147 131 174 141 6 253 103 225 158 200 230 223 71 209 146 169 204 96 93 64 11 95 190 173 137 14 56 65 0 94 21 14 248 208 225 211 253 78 30 141 100 250 164 82 196 255 213 92 218 85 124)
#f
())
#(85
"Replacing sequence with NULL"
#vu8(49 50 51 52 48 48)
#vu8(7 126 29 116 1 46 141 84 178 88 48 86 208 235 136 149 253 188 86 224 166 97 43 138 56 201 133 212 2 120 140 63 13 71 206 231 191 211 161 56 220 143 8 103 15 160 69 222 127 25 73 205 22 33 189 9 99 187 214 187 254 140 179 82 137 233 152 240 127 8 225 1 165 222 23 72 172 252 13 101 190 189 246 22 42 210 63 247 6 183 89 160 221 173 28 16 183 104 93 81 12 255 34 140 9 140 239 255 28 193 47 47 155 108 28 188 74 199 108 253 247 155 73 35 2 100 220 106 81 95 88 251 190 3 80 22 162 64 223 157 122 34 53 1 193 11 247 64 51 42 175 255 48 16 114 213 114 250 92 103 145 212 94 140 200 127 3 16 28 207 239 163 88 175 181 152 232 34 218 82 104 253 170 208 104 47 114 25 230 244 189 78 168 177 161 56 188 155 40 228 37 128 253 255 77 231 75 117 161 15 235 158 120 177 34 248 105 159 83 131 202 193 46 141 14 253 62 136 197 214 208 244 196 201 112 35 3 253 205 254 17 93 102 42 189 166 186 228 52 115 73 64 81 238 116 214 40 153 150 196 213 75 238 215 229 178 222 100 83 176 206 241 244 244 42 31 208 87 54 47 147 93 70 107 72 198 135 60 135 55 175 154 94 98 216 200 50 193 84 96 135 244 89 153 150 88 243 255 26 111 124 219 86 194 184 52 234 254 185 146 121 19 22 255 157 82 177 145 141 164 251 61 9 24 97 199 182 111 125 180 71 75 80 26 216 61 160 180 255 28 78 59 231 147 25 73 167 187 238 124 154 72 240 31 95 131 69 158 191 147 176 205 52 183 232 182 189 211 92 253 246 129 93 116 127 214 246 206 64 91 146 100 206 74 178 106 69 142 203 2 105 213 168 73 177 3 147 202 68 31 126 128 217 9 119 172 2 118 89 145 136 248 204 163 159 5 145 133 38 124 183 214 12 125 111 44 100 51 67 209 22 17 117 227 154 238 133 190 79 62 135 196 100 191 241 8 140 32 237 190 74 84 62 139 84 160 92 79 28 220 191 30 232 135 209 76 9 73 107 48 107 251 231 6 84 208 189 25 210 102 149 45 61 156 157 11 23 52 47 138 235 115 170 199 248 39 229 61 162 88 92 114)
#f
())
#(86
"Replacing sequence with NULL"
#vu8(49 50 51 52 48 48)
#vu8(153 77 214 76 219 98 51 176 159 244 178 165 18 111 80 195 220 1 136 13 13 138 195 233 213 194 211 75 188 2 198 116 88 61 219 154 82 13 230 67 172 129 241 173 64 120 85 218 113 94 128 127 32 10 147 16 252 26 19 79 13 110 60 218 158 191 84 30 132 55 25 153 97 201 106 95 97 126 7 95 223 62 55 120 138 182 44 57 60 40 8 6 30 110 217 47 114 194 89 22 236 142 216 70 215 106 219 49 20 209 95 247 122 50 59 187 34 70 59 202 77 125 125 149 168 201 205 171 238 60 27 35 102 65 166 22 109 8 62 183 247 114 203 169 61 9 69 25 123 246 185 168 165 74 36 197 241 46 110 213 32 234 195 238 154 162 68 232 55 78 196 207 233 95 171 71 12 192 158 173 121 153 240 84 205 214 185 15 249 91 198 223 51 211 77 118 85 71 252 182 193 32 192 66 241 222 239 64 47 118 77 73 74 239 251 217 248 181 157 1 38 113 235 207 8 64 158 144 180 13 25 251 204 178 158 16 95 160 135 235 26 28 190 109 171 252 207 65 183 227 63 176 80 129 22 222 69 72 96 156 27 87 210 75 199 68 4 19 98 206 189 63 226 1 148 76 78 68 85 41 15 149 12 166 143 94 252 163 100 201 133 165 83 25 87 237 245 133 118 69 253 255 97 159 93 208 19 179 247 81 167 169 254 172 76 151 19 35 183 48 243 172 70 99 166 179 107 33 116 158 102 67 239 67 235 187 59 129 198 1 242 61 21 156 157 243 172 246 187 63 230 60 200 110 83 182 168 70 150 3 55 175 165 149 174 37 105 77 122 103 20 92 18 39 200 198 147 225 51 19 30 44 98 41 38 233 179 99 228 68 94 109 205 137 187 101 221 116 164 247 102 251 200 87 15 149 69 19 221 220 139 91 22 227 194 0 175 212 116 19 206 147 24 163 192 143 139 9 46 12 82 123 228 166 188 247 85 114 100 89 59 128 63 101 38 82 229 151 18 237 113 137 84 53 49 151 255 214 241 152 83 216 190 82 94 29 217 153 40 79 238 152 234 60 164 157 211 154 19 41 205 193 177 15 243 54 187 27 52 190 159 35 52 82 145 118 121 38 102 237 75 146 79 136 74 73 187 237 240 244 48 174)
#f
())
#(87
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(210 146 243 12 247 91 144 16 81 33 106 149 121 171 145 8 202 156 221 169 29 97 140 8 255 155 140 235 69 91 160 161 151 174 139 111 96 193 114 43 29 33 44 218 0 72 20 79 1 71 225 182 30 194 251 101 87 62 118 116 107 233 178 55 3 30 149 175 118 214 199 38 24 88 85 67 108 223 228 5 31 213 111 249 41 203 207 76 162 226 221 128 20 216 149 124 27 130 17 0 221 24 103 118 219 244 99 164 106 136 73 105 188 110 33 83 183 104 5 160 206 210 35 11 146 51 254 154 48 68 93 138 90 173 230 148 36 30 109 218 246 161 118 90 23 25 196 24 126 107 142 154 151 34 251 139 24 179 254 252 116 109 50 146 125 206 133 123 32 131 172 67 236 227 89 104 182 22 9 1 87 219 43 9 226 223 223 55 143 91 89 59 3 194 86 158 148 16 132 234 187 41 222 233 207 106 103 6 128 11 39 75 171 149 38 250 87 193 225 253 111 244 25 90 227 119 198 74 1 232 132 36 99 235 196 19 18 172 139 169 231 33 38 252 110 49 67 147 20 20 89 145 8 90 126 135 103 147 136 85 17 49 139 46 67 84 97 137 13 88 130 134 232 201 56 214 53 52 218 123 183 52 223 57 98 6 155 98 209 200 74 206 188 11 45 14 205 52 145 38 228 77 163 126 4 241 205 244 42 48 148 27 6 34 115 90 214 193 62 71 87 163 212 139 150 213 29 39 32 255 155 13 2 245 223 33 59 38 231 95 172 234 1 165 162 69 45 58 58 4 28 78 190 165 115 100 188 95 159 180 97 41 152 172 206 31 79 119 79 132 121 228 136 230 239 255 108 33 246 142 154 106 247 11 215 251 231 121 139 117 191 118 252 45 193 40 13 16 154 140 95 177 206 35 192 43 19 152 85 109 83 85 240 103 62 132 55 140 194 111 251 39 65 129 9 194 77 48 236 244 196 149 127 48 206 216 103 182 207 244 247 30 131 42 184 30 97 87 58 93 221 76 64 145 226 109 221 15 13 10 133 207 195 105 248 104 90 238 147 162 37 236 123 178 50 37 205 196 122 177 2 214 153 99 107 226 82 22 148 197 170 226 190 109 40 43 50 34 242 227 218 150 95 208 203 213 131 174 255 134 182 88)
#f
())
#(88
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(112 24 253 18 19 123 181 250 201 254 140 189 46 179 233 209 208 141 228 84 110 138 244 131 66 22 12 195 5 217 84 184 249 70 10 18 191 11 188 196 126 111 147 191 171 128 117 79 190 44 230 74 248 153 167 27 217 62 245 134 142 28 225 84 56 132 61 165 209 81 157 24 51 215 95 199 183 190 204 223 21 155 219 23 88 131 243 205 113 199 89 5 38 253 88 27 239 48 126 33 237 172 7 217 124 128 162 116 65 139 122 90 29 91 90 164 222 83 244 120 193 216 219 232 134 213 58 184 32 32 134 158 78 163 144 212 255 135 173 234 132 162 148 158 44 210 156 33 74 208 241 95 4 27 140 223 66 122 60 38 236 111 81 175 100 20 42 164 8 146 254 54 146 210 2 14 180 185 243 242 40 90 32 239 1 68 229 129 233 138 72 68 180 196 149 251 98 19 192 1 18 202 17 79 148 80 184 171 187 114 125 254 232 209 162 155 86 184 71 204 239 29 172 142 202 77 218 116 5 4 164 172 23 42 138 66 43 247 240 116 218 228 155 91 130 105 55 95 255 244 209 80 240 127 96 93 151 163 218 198 38 37 194 90 129 243 245 67 109 54 242 56 106 84 26 92 189 55 104 242 254 151 219 252 201 211 0 16 64 26 77 110 103 158 227 170 117 69 171 162 240 240 150 248 27 87 153 80 114 69 57 231 83 141 209 117 1 30 177 228 123 126 53 141 177 62 119 133 152 28 227 110 209 63 151 157 75 215 32 114 143 45 55 190 199 37 115 170 188 248 191 41 144 147 44 142 71 133 152 167 44 219 52 239 178 15 102 179 181 48 164 121 198 121 98 11 248 147 179 255 14 51 232 90 58 109 177 215 45 124 135 249 48 105 119 241 138 135 70 23 155 164 148 142 81 250 153 109 93 188 194 123 180 241 199 137 254 186 59 25 37 185 192 175 116 77 41 77 225 55 94 248 245 43 168 117 52 68 215 152 54 58 118 165 248 74 31 165 66 228 49 248 68 13 249 87 204 115 27 123 236 78 74 182 229 47 9 34 25 55 74 82 94 194 34 2 157 174 100 72 164 23 2 167 204 137 32 5 136 33 169 121 10 63 168 200 142 208 98 131 180 60 140 225 95 236 65 56 113 60 251 253)
#f
())
#(89
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(73 26 68 177 128 151 217 214 46 13 62 180 27 63 1 114 243 100 125 101 217 255 203 237 195 30 230 143 3 245 39 149 253 197 250 117 63 200 189 119 162 29 204 175 172 87 146 76 64 81 235 137 255 209 124 12 112 63 185 217 104 192 209 139 39 98 172 2 250 247 45 138 180 72 165 208 22 26 21 235 74 185 35 242 143 130 221 110 151 239 97 254 78 239 219 99 6 106 20 14 213 172 72 109 160 22 7 27 222 6 182 23 136 158 191 236 124 113 238 63 102 243 92 254 238 46 244 158 84 145 2 28 38 215 62 217 32 200 227 145 53 20 246 94 164 157 84 83 135 107 133 136 93 81 191 2 101 152 53 120 255 208 93 200 223 142 252 13 145 94 144 164 206 241 129 205 8 152 190 254 186 115 0 133 93 226 26 66 96 10 79 178 210 235 127 237 91 179 249 64 175 61 28 247 64 79 159 107 179 218 134 63 189 226 70 244 211 147 18 120 251 116 133 213 156 74 248 166 245 53 79 244 224 81 83 40 15 111 214 1 90 19 250 21 67 155 155 78 161 194 12 230 129 172 249 42 172 79 96 168 111 173 95 106 99 106 126 21 129 179 248 252 28 144 255 5 140 64 181 208 230 75 125 130 5 106 91 209 250 102 22 16 56 44 146 150 123 237 234 87 175 94 175 82 215 48 78 119 78 79 133 218 240 157 156 197 192 57 213 189 171 100 151 3 4 64 71 130 142 242 41 23 119 6 29 228 151 222 109 58 190 29 43 125 12 82 68 166 205 125 49 115 39 246 229 150 177 170 165 82 178 211 4 139 189 38 238 227 23 87 170 218 176 228 57 70 15 83 15 169 11 146 102 88 86 32 30 70 117 233 156 108 33 115 254 225 130 137 84 242 249 207 211 36 255 31 155 119 214 235 13 72 241 116 93 192 31 180 118 26 0 209 210 157 233 192 52 213 2 101 139 41 38 246 243 194 131 248 45 172 200 91 142 48 111 152 129 167 90 113 194 187 3 243 107 93 220 68 222 82 92 195 175 12 114 177 175 1 196 68 94 48 80 88 175 36 253 229 86 149 148 230 86 206 133 25 47 148 9 198 187 127 95 160 134 34 220 0 16 43 164 248 254 127 119 98 172 48 80 170 192 240)
#f
())
#(90
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(201 102 125 149 143 150 70 116 5 118 206 24 206 48 133 251 175 111 51 146 82 68 35 190 131 141 113 175 92 87 111 45 18 236 226 28 48 218 14 32 153 33 190 174 117 107 154 182 168 176 76 60 193 12 6 220 215 133 161 24 244 91 89 204 80 190 63 62 98 236 1 231 13 14 157 88 89 224 152 251 78 177 114 206 67 14 50 165 238 29 17 169 79 116 155 188 13 68 78 158 3 187 38 50 188 97 26 112 161 230 164 202 207 201 17 130 71 236 211 116 246 40 211 172 197 204 167 149 114 228 91 244 169 75 193 218 99 26 89 228 183 129 184 131 104 151 159 58 144 154 1 204 124 79 197 67 253 22 91 103 200 45 143 130 183 150 25 137 223 236 142 156 79 166 7 124 137 67 138 102 103 228 43 230 74 165 105 68 172 67 199 239 248 228 185 169 250 43 150 141 162 161 243 240 59 247 168 14 136 77 34 182 211 255 69 100 68 79 165 219 239 190 98 54 27 253 70 195 42 180 42 39 195 248 25 205 86 1 100 121 164 10 209 56 179 40 133 96 230 161 243 131 27 218 197 195 232 80 195 242 206 80 15 118 104 67 84 159 90 243 46 0 41 65 181 12 216 140 232 34 164 97 131 244 147 141 88 193 44 241 126 26 178 157 169 76 13 243 104 211 145 3 24 88 38 36 205 102 241 191 8 199 239 156 41 167 72 154 222 128 134 183 80 244 50 225 105 150 118 166 72 48 153 233 221 205 63 169 119 27 14 213 141 191 219 63 97 248 130 121 158 32 17 77 231 198 224 56 71 133 169 238 107 34 38 107 40 22 212 133 174 9 237 45 113 212 248 187 0 19 201 50 196 119 116 94 234 54 191 254 211 171 248 234 186 213 23 17 128 136 254 125 108 34 192 24 224 187 207 240 122 184 20 245 65 255 30 74 88 4 44 190 161 191 157 93 111 105 80 105 27 198 28 185 24 41 110 5 185 116 125 35 3 8 90 142 144 87 173 210 177 9 166 97 73 14 53 126 189 16 168 136 140 127 252 127 231 136 202 61 167 187 186 82 168 198 176 86 117 77 136 204 45 194 174 204 26 125 215 112 209 157 10 148 18 134 13 26 61 124 223 144 90 185 47 211 125 85 158 78 86 121)
#f
())
#(91
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(1 57 166 197 115 152 236 2 162 156 189 71 161 17 41 245 28 7 182 22 89 208 216 63 166 138 22 86 71 149 166 105 187 22 78 65 98 209 159 133 33 41 173 19 85 134 164 34 123 145 197 76 203 177 230 160 46 10 75 29 30 116 18 145 213 8 172 46 159 116 187 210 122 45 61 74 129 15 240 22 251 189 84 90 71 159 190 39 163 124 205 70 42 156 178 44 188 213 217 158 167 249 156 228 163 227 206 59 186 45 184 125 67 67 178 35 4 67 108 96 117 47 107 175 51 211 207 77 17 15 123 27 150 65 16 253 250 46 0 88 21 131 37 231 139 91 64 16 128 26 168 202 89 152 111 98 153 18 120 28 236 235 195 63 125 158 219 111 110 213 41 254 224 111 84 236 46 98 198 244 183 43 221 200 171 110 163 13 184 53 116 188 147 28 1 85 219 38 211 165 187 131 11 24 64 197 68 177 85 120 140 102 164 46 108 129 97 240 90 3 224 91 114 113 87 141 131 128 148 108 114 183 211 34 188 200 75 27 231 20 203 151 204 120 81 208 110 28 184 146 255 57 216 143 130 26 91 235 192 67 19 83 38 173 218 244 128 196 201 155 33 194 106 249 4 212 26 1 77 86 17 244 36 129 118 146 40 5 71 41 151 59 36 138 222 49 164 234 150 58 98 103 112 197 249 39 119 130 50 142 160 99 94 58 95 96 19 80 30 98 117 180 25 241 69 203 96 202 47 187 58 124 75 202 215 68 156 71 169 51 109 101 139 196 169 163 192 107 47 132 238 157 138 130 9 255 126 208 80 81 68 49 29 243 52 45 127 178 86 22 195 21 102 242 157 214 19 154 172 57 30 120 50 252 208 166 187 105 206 231 76 198 163 154 44 178 159 234 216 43 210 62 194 114 230 43 200 118 86 235 163 74 90 68 244 67 214 157 226 165 114 179 215 233 213 67 94 230 159 108 40 19 98 201 250 185 158 247 44 126 4 187 141 79 243 68 151 178 168 15 92 183 80 70 45 19 28 172 109 160 144 123 143 192 76 220 69 166 156 34 193 60 119 96 106 109 108 187 123 39 236 101 253 191 73 107 18 58 51 35 176 55 11 3 28 232 57 214 62 46 30 245 155 13 149 230 70 202 233 75 237 196)
#f
())
#(92
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(29 104 19 197 250 118 109 68 55 227 252 248 195 142 124 248 41 240 46 186 12 188 251 54 155 123 8 123 206 252 108 95 101 21 109 14 148 125 159 83 124 216 133 212 220 96 80 8 58 235 38 244 19 172 8 41 137 177 223 94 254 124 253 124 202 42 154 205 234 75 143 103 62 217 67 246 89 28 162 230 3 9 79 190 93 196 88 124 228 24 40 179 234 8 37 94 204 165 236 101 149 243 38 210 150 22 233 196 124 216 137 208 99 173 139 144 50 97 99 255 243 1 10 82 5 136 58 232 108 108 201 93 144 228 73 86 109 119 24 115 229 211 202 117 132 151 47 130 64 21 236 91 190 147 48 19 90 126 209 142 88 88 27 137 213 162 106 224 209 58 192 185 39 45 246 69 45 77 60 23 97 194 182 197 175 251 215 172 74 47 125 155 94 210 171 160 237 209 26 6 141 88 252 254 237 187 212 64 17 188 11 30 100 67 91 243 92 73 165 65 20 120 35 157 115 130 212 44 83 198 250 151 42 32 2 61 166 157 175 68 240 145 241 218 6 150 120 9 228 151 111 168 81 234 185 1 200 85 20 207 65 15 153 195 104 106 226 28 119 139 7 95 231 62 218 193 49 115 161 60 176 143 55 204 188 162 250 181 99 41 131 45 192 183 184 114 91 184 249 94 176 254 129 23 3 220 32 71 235 163 194 58 21 113 197 199 49 43 56 253 175 121 228 61 192 14 130 230 61 138 206 243 5 193 45 25 11 90 189 202 209 168 46 38 33 178 12 132 132 245 107 28 132 229 88 128 192 173 155 3 146 12 68 160 128 212 54 24 26 126 116 37 128 190 128 96 38 149 255 186 162 12 34 198 180 132 173 204 99 204 43 65 123 212 90 198 130 103 100 170 235 201 24 161 251 231 186 68 0 206 192 201 114 140 28 24 249 67 6 148 99 165 116 112 82 211 135 246 56 144 190 87 54 52 248 241 34 239 208 167 89 105 177 170 239 225 74 227 211 251 60 237 245 36 141 249 149 65 80 149 162 45 187 60 157 149 204 74 167 146 192 81 22 183 39 214 10 122 156 228 8 109 0 185 99 193 119 227 166 97 202 172 222 112 25 111 69 65 203 253 27 137 9 209 247 255 24 218 159 34 27 2)
#f
())
#(93
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(115 112 208 197 220 216 30 190 101 68 188 234 42 115 193 135 165 0 28 54 12 138 130 199 207 167 178 110 183 3 183 57 144 230 247 66 200 112 8 224 162 198 118 210 32 157 0 240 105 220 254 142 193 221 127 33 69 146 54 36 112 97 166 54 123 188 77 208 44 216 141 11 246 80 91 98 76 21 48 230 183 48 239 41 193 45 160 166 100 197 229 107 192 237 41 40 225 226 99 92 59 184 37 2 211 247 29 136 226 16 128 116 102 72 1 250 78 225 109 73 226 222 60 198 56 186 63 111 21 43 75 66 137 247 21 244 138 38 152 92 122 222 42 245 13 143 12 27 252 146 50 88 99 198 75 134 78 225 77 200 32 59 228 236 139 247 152 189 233 95 199 218 41 208 168 214 239 45 196 40 231 231 61 244 95 32 102 70 189 2 66 164 159 103 56 71 181 208 205 193 218 32 161 235 195 240 76 14 153 178 174 251 106 13 174 42 148 33 251 201 242 111 143 150 1 185 71 113 69 160 82 109 184 68 64 176 234 18 81 130 169 193 147 140 72 255 245 30 163 102 228 188 44 73 158 160 109 128 86 237 119 226 146 245 169 26 83 44 14 166 134 102 104 125 41 102 36 147 121 245 71 108 53 203 40 179 36 43 84 109 206 52 197 6 185 169 153 30 188 205 143 169 40 91 118 179 42 156 118 209 175 180 49 160 64 180 187 181 183 163 69 26 200 8 102 7 93 119 110 241 44 206 236 253 72 248 32 42 162 68 76 68 19 92 254 11 159 87 222 55 131 38 188 30 170 231 182 86 183 221 138 81 64 192 87 182 206 203 62 153 65 174 204 178 234 135 4 10 169 128 208 102 48 172 129 71 40 42 246 22 15 211 110 0 53 134 212 123 90 213 186 93 246 118 193 108 138 189 144 223 226 245 70 45 18 73 139 189 38 38 205 182 254 65 157 78 152 190 36 4 155 32 50 136 32 114 152 22 122 5 228 249 213 195 249 107 163 172 109 193 75 62 30 107 206 59 128 255 70 213 243 112 73 93 250 196 99 107 44 144 6 41 156 32 86 18 152 54 179 46 14 77 76 121 252 48 15 156 124 89 249 115 180 137 41 245 108 41 152 147 130 131 67 162 135 94 112 227 54 23 240 184)
#f
())
#(94
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(46 23 27 56 61 82 138 172 81 129 123 166 103 145 89 6 119 95 107 164 70 135 134 23 209 212 214 89 212 22 7 237 103 31 120 8 52 136 16 60 15 175 163 187 68 95 185 8 213 72 244 19 20 35 125 54 223 56 64 173 130 57 77 35 255 155 228 165 228 90 230 163 186 211 230 85 90 212 54 44 70 206 111 88 49 9 186 42 44 36 99 249 131 100 225 229 150 219 89 190 127 175 168 254 158 225 135 109 195 6 163 120 9 0 199 205 168 249 13 215 39 72 11 254 112 122 212 106 3 33 163 205 30 103 155 219 22 241 87 14 195 178 51 86 101 176 199 117 72 201 5 222 190 24 148 162 148 49 249 235 209 146 34 251 171 179 121 82 16 6 191 12 73 11 219 182 231 0 192 108 44 237 116 60 89 83 181 117 102 65 212 16 91 219 4 72 172 13 175 243 253 46 117 147 46 246 240 180 81 77 72 59 2 109 42 106 185 182 23 245 45 168 62 6 45 128 202 127 168 1 70 2 61 95 179 245 123 230 117 43 130 86 98 35 100 209 192 183 147 255 7 14 27 48 130 75 206 11 106 29 129 21 204 19 18 119 0 7 45 66 183 25 200 73 64 78 126 156 73 231 29 197 152 116 20 174 191 222 84 235 238 34 56 192 86 141 197 227 134 243 132 4 57 103 116 10 35 30 98 144 253 66 214 220 43 142 44 89 251 55 58 48 173 170 87 234 237 121 102 119 185 183 184 73 37 108 109 255 12 166 115 146 6 253 48 250 111 67 105 42 157 29 62 67 192 3 229 167 240 33 246 145 182 246 29 254 240 248 3 222 246 101 48 61 149 210 229 28 127 164 211 62 196 239 227 61 226 246 248 236 141 228 84 37 0 223 117 251 27 140 9 54 201 146 254 164 58 83 167 226 43 72 58 39 67 251 31 209 247 252 5 123 23 18 200 246 26 246 56 171 187 20 253 135 42 211 223 70 94 129 211 3 110 186 123 82 88 115 68 185 203 37 150 14 188 104 230 47 145 135 193 181 100 19 111 89 151 70 35 58 178 153 190 22 190 45 19 150 13 63 227 33 119 51 2 106 168 142 59 224 149 16 202 24 27 239 4 177 125 92 25 129 32 229 181 106 179 225 58 43 238 97)
#f
())
#(95
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(107 227 209 86 147 96 143 102 158 187 136 203 221 228 21 154 82 65 43 44 180 216 57 175 15 77 45 12 0 11 177 246 182 81 190 138 228 68 5 39 100 86 171 213 254 120 149 28 141 36 16 94 34 24 115 74 31 186 247 153 125 26 234 219 191 124 95 146 197 101 43 77 68 117 56 32 93 156 250 92 32 9 75 201 146 53 143 76 8 119 107 152 7 212 211 46 155 64 191 84 183 23 242 246 145 190 51 125 136 31 17 135 179 35 147 82 46 202 235 48 161 77 225 4 250 158 34 159 39 111 52 22 103 91 123 57 233 46 25 135 227 216 46 39 101 227 83 84 244 35 136 121 188 219 211 26 84 174 228 100 24 139 135 80 214 77 45 213 49 120 6 176 195 40 136 224 200 205 120 38 74 176 218 135 63 249 232 201 216 51 196 176 15 181 27 99 21 90 18 47 136 4 113 249 177 99 251 99 99 109 148 113 13 226 28 170 48 23 206 49 152 110 212 231 228 106 110 141 94 215 167 202 141 246 129 191 173 41 205 117 102 233 233 226 113 109 55 73 74 160 191 151 228 18 248 231 255 192 5 111 160 210 0 10 225 81 230 167 70 41 14 142 240 162 173 184 188 145 137 184 220 203 201 183 202 89 222 211 251 123 17 53 194 97 222 42 134 61 174 86 115 207 121 52 20 141 170 148 209 218 142 87 107 159 86 26 249 98 226 65 28 93 15 61 176 197 65 10 219 125 253 156 37 54 110 215 40 147 137 211 133 154 252 146 211 133 251 223 0 21 49 100 245 241 109 148 112 0 44 102 149 0 152 142 74 14 65 61 91 83 8 167 163 0 110 175 219 199 243 230 113 15 132 216 231 109 67 240 203 192 154 104 109 123 2 58 173 2 139 185 26 114 164 175 39 27 167 65 213 235 133 59 222 216 232 44 17 41 124 160 133 56 97 193 143 137 0 47 118 146 143 90 244 219 62 219 121 249 27 112 228 197 233 130 3 1 17 80 72 138 222 205 236 46 32 244 236 110 141 234 138 65 26 69 54 61 248 129 209 202 50 168 190 230 242 113 31 221 117 197 204 139 39 160 69 9 224 227 168 50 251 131 9 13 50 181 32 219 96 199 134 124 242 196 66 109 239 98 44 18 13 74)
#f
())
#(96
"changing tag value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(143 137 152 26 86 201 230 109 75 207 48 28 87 197 122 12 46 226 173 43 161 159 73 127 85 59 137 140 79 248 131 254 251 212 205 183 218 132 100 206 240 40 205 243 83 151 180 64 217 54 121 21 196 124 73 63 97 218 123 250 42 51 235 98 164 164 33 174 187 81 131 40 115 146 241 34 226 138 73 99 228 85 102 226 95 239 24 22 7 19 65 178 141 170 127 88 107 214 169 15 227 246 185 215 134 208 229 125 252 94 75 62 48 13 93 206 51 119 132 202 95 150 116 136 252 171 147 201 102 74 78 255 242 42 33 61 18 122 227 145 133 19 228 130 75 91 4 113 160 45 24 138 29 169 124 249 78 130 139 43 173 234 49 232 29 193 74 225 151 193 8 216 34 204 231 238 251 95 79 173 39 178 224 251 186 141 142 37 219 123 38 182 65 26 135 207 1 198 49 103 95 243 205 6 81 186 103 164 25 194 154 75 159 192 29 205 39 59 218 151 20 161 2 143 85 249 38 167 180 105 228 219 240 27 216 39 106 156 4 223 36 246 83 149 92 150 113 243 127 0 27 37 67 52 213 53 225 101 159 205 77 225 133 242 21 21 200 176 7 47 106 155 110 147 254 1 149 203 84 128 216 21 113 39 12 172 35 224 90 50 128 159 32 73 48 202 37 245 84 178 41 128 176 240 236 249 159 65 79 184 250 114 205 149 48 219 188 125 213 206 70 73 12 124 145 15 158 162 41 173 136 164 118 255 156 254 205 131 220 30 156 104 237 10 112 36 232 65 168 20 132 171 113 3 198 230 105 93 223 78 222 85 142 156 72 207 163 215 238 174 43 235 202 120 237 91 14 63 104 121 208 203 76 89 5 158 23 16 235 49 66 119 30 99 81 67 7 207 65 81 168 152 117 234 90 242 197 187 8 115 160 17 76 124 27 67 244 122 237 162 174 236 98 176 198 35 71 147 255 20 33 163 106 70 240 128 95 229 254 91 141 175 35 77 72 163 102 75 95 56 124 146 225 164 202 103 204 61 77 23 131 69 109 75 26 145 142 184 51 209 74 12 182 242 105 32 232 67 238 93 100 141 19 50 98 74 33 233 26 125 35 166 45 252 211 254 231 35 128 213 157 120 4 26 82 215 227 20 25 47 179 216)
#f
())
#(97
"dropping value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(156 168 112 73 219 202 239 109 187 249 129 194 17 16 15 192 43 146 167 147 128 226 252 12 76 89 227 32 177 245 89 173 131 237 101 61 119 250 11 91 163 170 0 81 130 180 53 145 88 255 176 192 114 230 199 208 42 227 45 25 86 125 226 142 79 176 53 190 9 71 27 7 255 110 114 161 15 26 177 115 228 111 119 13 148 247 142 33 171 14 196 212 193 27 86 143 57 74 211 191 63 239 20 97 10 250 106 140 131 71 201 145 22 202 204 136 51 175 254 17 157 145 58 101 150 232 162 174 77 9 189 152 22 226 193 207 143 194 81 158 198 49 159 143 33 158 54 205 197 234 206 26 77 237 212 123 9 81 157 100 88 98 130 103 69 113 151 46 181 120 207 30 100 14 88 70 57 48 252 11 8 177 178 151 197 118 3 3 183 153 183 242 79 170 118 12 36 66 240 173 199 216 60 221 197 106 153 105 44 173 166 186 142 163 250 90 186 32 7 25 174 67 208 119 11 23 138 217 207 87 75 165 176 206 132 125 222 24 223 156 172 50 208 173 175 123 60 251 70 15 20 219 12 84 36 19 213 245 40 182 4 110 155 164 124 233 134 203 19 64 17 239 181 80 100 249 235 33 99 176 205 178 100 166 235 151 147 241 34 3 234 92 233 212 136 150 242 196 72 146 102 21 210 218 178 220 81 160 251 220 111 92 45 253 71 79 69 93 11 13 66 30 55 17 50 110 213 34 209 132 12 13 14 147 189 190 179 120 28 6 107 124 5 14 41 154 46 69 6 64 171 70 175 79 193 191 66 145 149 51 114 19 67 64 212 206 211 4 67 14 254 130 171 124 159 57 31 40 194 56 128 98 73 37 139 126 140 186 45 183 95 98 186 145 11 129 93 178 248 137 50 111 63 215 36 249 58 220 69 176 49 224 139 219 190 251 139 42 72 208 168 97 240 115 144 169 240 65 160 37 94 185 1 97 87 197 38 229 46 221 125 113 75 255 64 71 62 179 109 13 56 30 126 194 39 125 204 63 20 93 46 250 2 205 99 229 172 197 240 86 50 114 61 92 94 1 109 93 213 238 38 126 187 46 179 153 9 192 206 49 219 75 160 204 226 244 4 240 196 44 68 208 130 107 36 224 119 136 128 6 123 94)
#f
())
#(98
"dropping value of sequence"
#vu8(49 50 51 52 48 48)
#vu8(41 131 95 200 114 0 120 61 240 175 254 21 251 249 231 133 11 33 24 12 201 3 60 153 24 82 14 79 237 62 251 216 244 26 95 140 85 139 55 119 130 213 198 180 207 3 141 188 125 8 76 206 232 141 59 187 243 58 125 10 221 185 95 14 20 155 57 196 164 188 180 238 145 140 113 150 250 209 213 145 161 102 179 105 239 254 29 111 62 66 187 100 89 127 183 161 82 213 29 24 212 95 69 249 160 89 58 218 253 54 229 34 161 225 247 119 100 123 34 81 4 219 186 195 31 30 8 202 71 109 214 21 38 225 140 76 106 141 228 206 67 116 225 57 50 99 119 209 17 34 250 104 93 238 7 79 245 84 28 136 214 101 42 241 229 161 184 251 66 229 245 145 199 16 29 18 245 23 43 107 197 192 0 40 137 213 231 70 83 213 224 168 110 79 172 117 108 226 14 175 90 32 202 181 30 91 107 93 201 158 28 72 17 68 234 34 116 93 45 126 108 152 183 234 78 219 254 1 97 22 159 234 36 0 211 38 197 60 197 188 214 11 178 223 52 90 145 51 62 7 110 227 28 0 53 5 193 157 247 188 150 54 80 20 164 19 173 192 126 220 134 187 239 37 92 38 164 108 189 252 56 31 35 25 45 231 199 104 151 109 200 231 81 85 174 141 7 190 186 10 241 34 248 165 221 142 220 77 66 88 37 113 11 246 132 93 168 0 141 191 106 182 187 122 91 202 142 231 3 124 150 130 248 180 226 165 149 66 144 212 155 242 176 169 231 174 226 45 99 19 107 124 194 253 126 108 196 139 76 136 232 198 5 32 212 221 183 147 198 156 177 198 119 208 23 112 117 110 88 229 132 107 191 134 142 10 89 150 194 255 127 174 178 219 161 148 64 172 186 65 250 81 79 132 40 62 102 84 124 93 158 77 248 22 93 244 2 3 50 152 117 156 144 108 154 250 141 209 89 51 87 49 131 213 38 155 74 154 44 99 213 99 111 139 46 8 57 145 152 151 251 230 248 125 210 168 205 238 250 85 156 183 7 30 210 236 24 215 159 224 104 207 143 107 188 77 208 218 215 246 247 204 134 158 171 209 235 165 119 89 1 205 36 140 181 0 210 49 16 234 192 237 32 106 22 73 69 59 129 181 131 182)
#f
())
#(99
"using composition for sequence"
#vu8(49 50 51 52 48 48)
#vu8(75 177 81 53 255 195 45 42 126 89 165 197 54 208 120 142 195 118 51 185 177 229 201 74 219 159 91 1 200 69 219 250 177 41 25 75 138 83 97 243 82 104 45 232 245 169 47 10 105 29 247 126 6 161 71 194 170 117 158 181 187 114 202 150 235 202 51 54 115 96 226 45 25 240 212 217 12 37 195 226 202 55 133 165 207 38 251 128 225 153 63 252 8 220 159 61 76 21 84 229 233 10 70 162 31 143 0 162 203 55 106 196 239 219 231 46 10 177 48 139 188 250 131 185 180 132 244 63 188 179 49 26 110 228 146 126 7 197 104 249 119 84 94 125 91 129 121 230 97 44 35 17 213 177 12 114 104 28 150 85 178 82 144 23 242 69 99 145 149 228 22 254 12 40 0 133 63 250 56 123 176 147 74 169 119 173 174 162 161 63 184 125 47 137 3 203 54 44 26 225 244 232 79 225 61 41 188 255 228 221 146 248 86 219 108 95 30 150 34 38 141 160 144 168 207 133 72 16 54 193 93 109 155 201 118 135 160 155 203 217 46 115 172 144 8 210 41 136 137 59 247 142 195 239 135 98 14 226 118 51 250 241 251 243 202 163 183 147 35 201 153 147 42 114 139 64 41 74 206 85 198 199 199 62 208 252 3 21 26 86 199 168 121 98 222 231 87 162 152 146 129 29 212 206 217 80 11 139 220 144 89 70 87 90 217 82 23 88 133 103 128 251 75 97 146 235 107 82 168 30 154 30 233 198 229 99 165 104 43 134 117 17 9 58 20 247 53 245 242 11 214 226 202 29 1 228 198 89 142 166 52 123 188 97 218 198 166 157 5 145 78 113 111 241 213 62 240 184 37 158 61 175 194 3 194 65 102 243 32 103 32 30 17 194 65 173 76 16 113 121 185 59 62 37 77 239 181 198 127 45 136 183 50 171 233 110 165 206 9 203 54 2 152 241 163 75 135 168 134 12 50 7 157 92 128 206 63 70 41 174 39 244 115 18 147 41 79 194 171 124 217 242 252 16 26 216 125 212 137 231 162 176 237 204 163 121 16 213 27 138 239 232 8 116 8 142 197 60 13 86 84 138 212 118 30 241 74 152 135 57 160 44 224 143 207 129 147 93 167 246 92 55 87 135 116 11 148 212 141 129 104 241)
#f
())
#(100
"using composition for sequence"
#vu8(49 50 51 52 48 48)
#vu8(146 152 182 239 126 236 115 102 92 132 142 80 226 194 33 160 19 185 81 136 138 133 209 247 70 91 225 163 6 249 188 35 155 32 111 195 168 92 205 67 139 142 69 172 72 146 71 140 73 69 223 104 73 230 20 140 98 168 31 140 88 248 199 140 164 190 50 128 106 61 139 22 193 162 88 83 79 26 93 150 148 227 100 194 116 144 239 49 232 180 91 150 200 138 16 130 157 144 42 164 131 150 251 22 70 251 90 80 73 103 128 234 69 90 47 145 138 145 76 132 8 22 93 17 101 27 45 73 8 116 216 112 178 194 214 192 199 60 246 84 195 82 32 7 184 251 212 241 172 89 144 108 247 25 34 141 23 149 204 71 156 157 243 167 186 168 31 92 183 29 140 115 209 84 185 14 77 51 210 8 243 17 21 14 8 244 134 231 111 193 120 107 238 63 40 122 139 7 167 104 249 26 233 214 92 53 41 96 21 104 38 87 128 3 30 53 146 115 249 63 247 223 97 15 71 200 208 176 37 208 23 225 221 8 138 103 111 206 195 144 153 247 139 37 25 47 203 218 10 52 199 159 186 166 165 171 181 84 227 186 190 56 110 126 34 70 212 246 143 11 214 13 96 54 19 62 164 81 161 46 124 62 209 56 46 83 154 1 251 60 33 225 210 27 231 237 147 114 185 67 147 122 228 133 122 219 122 255 39 33 165 245 172 236 37 128 242 231 98 13 127 200 204 32 251 49 93 219 66 70 26 190 147 232 184 145 22 19 208 110 15 193 148 122 99 118 196 48 131 117 98 248 238 131 72 193 242 8 106 203 214 15 141 233 89 53 95 253 92 180 245 142 253 146 145 83 143 149 116 253 148 231 92 122 119 16 161 25 247 238 117 196 172 14 212 158 69 183 3 178 245 227 77 176 79 183 20 120 203 239 66 146 245 155 42 118 237 24 181 25 146 241 100 184 137 3 218 150 106 12 163 253 185 132 88 151 158 247 158 248 49 34 166 188 33 148 237 15 115 123 117 192 43 215 19 198 112 226 106 161 152 131 50 116 129 89 122 152 4 117 64 94 141 196 244 238 188 251 53 231 203 115 160 85 36 201 44 21 153 149 15 2 38 193 31 39 33 230 88 103 59 169 171 223 139 179 159 227 190 118 225 167)
#f
())
#(101
"truncated sequence"
#vu8(49 50 51 52 48 48)
#vu8(16 180 232 121 242 123 85 63 244 38 194 9 101 141 120 114 25 235 238 201 189 186 9 175 173 241 67 98 2 43 193 246 227 91 224 136 149 189 161 198 116 101 199 79 140 34 93 224 45 73 135 143 70 5 21 131 31 31 177 220 212 43 37 71 85 139 168 5 184 90 151 225 124 237 10 31 27 203 106 165 172 57 1 41 145 111 167 151 38 69 42 242 116 254 101 169 99 7 75 231 7 16 197 148 99 227 185 14 105 225 254 64 220 129 5 242 253 199 248 99 204 157 128 140 104 120 72 4 49 184 71 243 114 233 207 100 24 32 62 156 154 38 123 198 203 26 19 119 195 148 176 242 214 153 17 212 134 80 113 118 68 199 159 208 43 53 92 71 144 97 14 233 48 194 233 207 31 161 254 215 43 17 31 63 65 131 162 206 211 211 173 237 107 139 95 243 184 11 78 208 14 151 170 106 30 148 126 149 253 173 119 217 30 54 71 47 201 50 111 116 92 113 39 178 49 236 165 178 220 161 97 213 66 156 13 76 79 177 95 67 224 102 216 13 200 76 250 80 148 159 77 254 63 58 28 154 246 174 250 206 242 6 4 253 77 136 75 70 86 147 28 13 59 192 42 112 227 124 129 15 199 117 134 57 228 113 10 34 147 72 225 52 181 166 116 67 220 54 133 63 221 223 99 43 118 136 231 98 34 71 190 77 71 179 157 143 141 214 57 249 163 45 179 189 175 62 69 68 26 136 7 1 122 159 7 139 175 137 235 70 228 78 36 132 226 37 134 132 38 88 209 174 57 188 180 182 190 62 85 24 7 159 177 15 172 156 246 234 157 30 152 163 152 97 72 236 131 76 242 208 14 54 94 248 180 90 248 231 180 248 239 28 54 252 103 90 167 4 38 157 92 28 195 78 99 244 54 46 82 124 60 66 188 243 140 43 18 98 188 53 3 115 148 26 80 16 43 95 47 17 117 186 9 217 213 35 90 108 144 211 219 40 117 84 91 115 48 204 100 212 74 181 84 62 222 33 30 151 54 18 75 168 141 179 118 128 87 78 34 93 235 134 228 11 28 41 67 238 165 184 53 20 134 199 92 215 83 109 109 168 218 216 35 52 205 230 243 204 85 3 61 9 195 135 214 171 218 125 152 57 142 71)
#f
())
#(102
"truncated sequence"
#vu8(49 50 51 52 48 48)
#vu8(166 36 134 230 181 198 219 185 24 230 222 24 102 75 246 242 168 200 222 107 192 179 179 35 253 183 54 250 244 141 156 202 39 146 248 66 179 165 232 5 72 162 67 171 89 114 92 29 214 178 220 225 133 176 96 0 139 98 59 226 24 169 153 113 49 16 107 71 235 43 218 136 254 148 121 172 141 83 150 152 182 243 179 225 78 236 179 195 167 248 201 227 157 83 152 222 141 28 94 159 207 213 43 200 251 78 115 49 154 130 72 249 201 149 146 170 169 186 140 127 68 20 47 99 189 133 31 33 138 154 115 132 88 18 248 101 185 33 250 238 216 189 253 139 97 185 142 162 111 171 9 204 144 247 142 30 113 75 62 166 148 143 22 71 225 37 143 47 185 101 164 7 209 88 47 40 102 59 118 225 135 25 123 113 226 9 189 207 59 114 35 193 89 107 154 162 223 30 39 54 206 175 79 184 48 69 148 21 85 106 165 47 71 203 38 227 226 46 77 219 186 179 144 74 123 25 104 232 54 97 245 200 160 43 181 11 51 32 11 233 40 205 241 186 189 121 78 88 231 152 144 67 95 78 111 58 247 155 112 21 167 221 125 153 111 37 214 29 107 41 189 0 52 68 90 182 216 182 100 102 124 167 187 69 55 241 158 219 154 177 245 142 202 174 61 216 197 106 7 181 125 156 182 7 37 189 169 5 126 61 156 82 207 23 202 161 212 53 248 2 33 73 144 29 39 227 177 82 137 142 56 101 220 251 5 128 40 24 56 167 47 239 69 131 40 204 17 48 229 157 79 105 229 141 181 253 69 82 147 140 24 33 40 254 150 122 66 200 65 57 40 0 133 129 189 65 134 94 12 116 123 125 91 231 223 80 67 90 220 199 7 224 12 120 55 164 93 168 166 231 166 199 171 95 93 52 148 243 109 159 152 188 47 66 47 59 244 193 255 9 24 82 158 239 243 212 232 229 129 126 194 32 33 245 122 44 102 7 139 134 34 255 78 237 234 184 187 97 54 36 136 226 21 118 13 216 47 243 165 138 197 223 45 208 211 128 115 236 87 64 132 220 232 42 169 160 86 50 143 229 234 185 230 55 170 113 185 214 186 49 127 171 185 105 68 198 94 170 0 57 157 39 147 37 42 74 113 64 225 120 13 107)
#f
())
#(103
"truncated sequence"
#vu8(49 50 51 52 48 48)
#vu8(180 142 70 157 122 65 30 21 33 36 79 136 23 207 23 86 101 23 150 147 87 244 168 231 18 151 212 141 115 104 134 121 49 134 221 100 137 70 190 248 249 215 79 135 176 208 73 14 110 181 141 207 207 124 53 4 173 206 15 178 136 108 23 78 4 229 238 5 68 70 86 7 68 26 8 169 58 61 142 244 27 222 134 60 5 163 130 93 8 62 72 87 81 117 184 151 121 43 165 71 231 155 56 171 37 184 156 0 103 226 141 200 1 78 81 72 108 140 213 193 122 25 13 255 35 117 243 169 32 250 28 56 121 236 183 254 56 126 221 33 92 172 114 244 144 205 112 24 238 23 212 106 15 77 95 173 11 105 167 75 100 171 51 99 65 92 109 94 219 91 105 170 152 49 152 77 36 186 95 77 28 177 146 193 156 220 76 9 83 117 221 94 90 86 43 23 218 216 221 227 71 65 200 101 119 46 178 69 26 252 251 69 170 166 2 62 89 50 164 213 254 14 219 212 209 221 55 39 103 85 147 138 71 170 51 146 97 16 19 196 145 150 43 113 119 68 16 125 47 117 111 152 8 162 162 85 16 121 39 116 131 171 104 11 18 137 242 244 38 85 255 231 112 199 139 143 33 207 190 70 26 159 46 132 41 131 127 127 21 190 137 23 151 223 197 138 181 146 98 230 151 160 59 158 243 81 224 138 185 67 251 172 199 216 192 210 60 115 81 233 58 17 182 20 221 140 144 36 160 162 251 250 145 236 4 190 97 27 76 90 40 34 120 195 60 90 161 80 13 49 207 107 125 170 143 39 21 139 242 129 33 104 79 36 232 215 158 112 107 235 105 100 82 255 183 28 78 194 194 185 144 70 18 227 0 246 31 233 116 110 179 112 179 113 159 199 150 78 52 89 248 230 28 152 213 177 233 236 233 41 56 29 107 209 159 250 213 160 255 54 230 33 77 39 160 37 151 41 168 53 143 228 222 212 25 87 109 148 222 10 39 224 130 143 149 214 11 11 37 165 103 227 151 166 210 164 94 146 161 97 173 107 218 245 3 161 182 113 29 24 162 244 174 218 1 183 144 243 24 125 108 183 78 210 60 234 96 113 97 5 239 101 201 192 20 118 200 70 160 231 247 60 1 255 231 233 119 78 116 189 208 221)
#f
())
#(104
"truncated sequence"
#vu8(49 50 51 52 48 48)
#vu8(65 79 68 101 67 73 171 30 229 147 52 112 149 114 71 191 203 237 59 218 113 191 175 150 136 82 63 243 177 152 80 11 94 55 166 38 52 203 162 42 15 226 248 184 190 148 152 252 145 108 112 78 16 112 211 148 0 5 216 137 225 97 131 116 208 3 91 217 25 141 206 244 166 181 183 187 220 193 113 77 206 94 33 101 143 16 123 226 217 14 16 236 4 141 95 39 52 240 77 88 203 243 132 180 40 44 131 158 60 88 127 221 134 87 200 32 19 9 23 141 189 250 229 162 224 242 241 99 71 76 215 219 170 237 172 144 120 42 193 135 180 147 244 243 96 64 184 169 50 18 83 51 93 231 168 68 2 234 43 180 166 70 100 3 0 128 198 156 5 132 38 201 82 189 72 61 230 105 23 96 222 11 141 19 185 74 199 44 143 229 127 186 238 229 72 50 183 81 17 19 189 228 80 21 143 252 150 130 20 147 227 124 251 109 33 21 107 59 192 56 236 100 244 228 179 225 229 208 27 64 152 47 82 4 18 20 197 88 0 249 18 156 43 156 118 6 15 147 23 40 94 121 166 102 254 52 82 212 241 63 225 189 31 12 163 37 77 125 191 12 165 215 64 173 168 219 145 106 26 131 5 214 150 149 103 243 154 47 242 102 47 54 66 97 45 238 207 10 153 20 148 32 148 126 121 132 23 43 181 78 254 141 215 47 124 174 67 153 71 200 202 121 67 98 9 214 222 91 101 244 37 66 242 76 51 114 142 91 49 146 167 107 201 234 81 220 29 36 143 65 56 29 137 140 202 68 29 206 163 197 21 233 207 21 114 157 207 218 173 92 36 145 16 37 79 226 246 115 134 50 181 194 164 9 11 118 203 253 75 35 55 129 56 226 27 37 172 227 99 94 246 143 61 103 148 71 204 116 78 246 216 128 253 83 41 5 139 46 169 204 161 234 175 139 179 28 142 11 171 19 66 151 93 38 142 180 232 252 239 161 247 2 206 22 54 172 4 219 250 119 47 210 231 120 173 137 196 202 169 172 203 110 58 99 36 190 126 82 19 121 13 128 180 226 23 243 98 179 76 225 237 225 38 119 239 84 126 141 215 186 34 159 200 8 206 49 73 23 100 188 248 85 147 249 50 9 101 86 183 212 4 161)
#f
())
#(105
"indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(19 50 240 17 178 4 86 44 200 61 95 42 132 96 108 201 175 232 166 163 116 4 17 146 224 45 19 244 37 231 95 155 109 182 139 244 0 65 88 250 17 189 89 30 199 182 59 86 142 24 241 145 145 181 185 198 124 178 222 251 95 174 198 20 15 36 12 0 20 57 110 157 110 143 213 160 248 77 218 135 244 164 108 59 147 60 52 191 245 88 131 173 170 112 197 205 61 105 185 51 38 253 238 197 62 125 28 136 151 73 72 85 246 216 60 33 71 15 11 210 36 139 15 115 29 69 0 59 127 88 151 190 75 195 153 56 101 166 165 48 149 42 101 5 207 73 239 108 110 49 154 88 31 115 166 27 32 204 103 138 244 93 83 250 51 232 190 153 136 174 192 151 187 170 34 187 149 68 152 90 35 197 93 248 162 169 119 110 170 166 130 187 112 96 3 249 61 22 105 86 70 51 12 138 4 117 248 73 0 48 91 64 249 178 229 77 82 46 192 55 42 172 181 16 144 121 217 219 25 192 53 149 173 112 53 10 174 239 218 193 32 9 164 185 137 138 180 37 156 197 162 149 36 242 0 7 114 68 13 61 5 38 207 199 242 215 128 136 136 50 183 82 122 63 199 181 223 118 61 77 77 119 71 18 195 20 65 38 154 173 190 117 55 139 231 22 191 11 79 92 243 22 71 7 200 168 211 0 149 117 100 197 193 37 129 25 217 136 181 156 242 34 149 13 232 38 36 111 79 181 222 17 30 139 114 214 167 176 56 201 208 58 195 178 208 97 160 124 125 109 59 87 72 96 204 232 217 88 204 246 118 50 69 153 179 62 143 240 210 78 36 242 94 67 65 253 189 135 39 37 200 75 182 102 230 4 205 110 117 33 203 71 138 168 14 200 49 39 154 234 89 6 84 168 72 10 213 69 223 150 216 151 40 192 222 158 70 113 138 109 205 116 117 138 195 84 180 124 119 47 35 202 214 9 239 99 87 38 108 77 33 120 117 40 193 107 231 226 183 78 35 219 67 94 146 129 2 155 107 148 27 248 124 158 249 236 194 34 194 191 125 159 235 5 253 130 170 213 114 208 63 179 146 68 85 23 233 58 182 35 26 233 255 147 84 221 171 77 73 175 160 41 21 99 226 131 230 236 58 123 236 51)
#f
())
#(106
"indefinite length"
#vu8(49 50 51 52 48 48)
#vu8(191 45 111 193 5 218 110 155 32 40 100 236 54 150 29 163 49 72 192 43 62 240 25 25 181 66 82 69 140 72 217 196 126 142 108 68 246 141 240 115 190 118 5 122 76 233 159 127 57 164 38 133 82 42 29 60 185 244 161 161 108 218 203 7 159 195 245 148 119 38 71 141 64 60 236 79 109 133 71 248 17 63 244 42 178 194 160 72 206 187 127 141 152 157 107 134 144 181 44 25 73 79 125 187 78 159 84 176 50 51 240 92 240 104 247 21 0 107 11 162 45 2 123 43 2 108 80 105 13 230 189 239 182 142 54 206 55 116 186 73 107 79 214 235 155 77 199 87 86 244 146 233 26 126 255 52 223 52 115 158 228 201 212 199 14 40 207 13 16 30 247 174 19 28 96 45 58 209 122 223 166 250 107 45 158 41 11 211 19 53 69 216 248 111 217 113 144 104 191 100 102 145 107 31 238 55 85 6 244 117 147 96 220 103 57 78 181 242 235 130 41 180 242 92 242 87 213 172 121 132 148 249 54 180 88 244 94 151 187 176 229 85 199 255 10 131 235 76 171 255 175 10 203 98 165 186 243 235 118 165 113 170 92 111 238 6 109 157 207 78 232 225 20 249 177 166 123 137 222 49 28 45 78 99 5 51 2 36 193 10 170 128 80 195 15 126 182 17 181 68 199 76 62 118 243 142 204 25 59 255 216 42 47 181 83 135 99 219 64 165 141 134 197 211 8 211 252 64 247 233 210 252 118 10 185 30 193 120 114 144 123 226 181 181 156 248 182 60 92 182 119 224 71 16 5 234 188 231 7 118 54 30 44 201 30 152 187 146 93 85 118 213 233 48 123 145 227 13 99 207 189 27 119 188 190 48 84 29 194 230 54 123 117 191 222 156 190 203 222 220 123 110 131 226 1 113 100 52 252 21 151 5 174 51 78 116 65 126 53 213 224 133 64 245 144 97 133 92 220 235 27 255 18 72 16 214 180 76 103 56 3 37 123 143 176 209 211 129 163 112 213 95 59 245 157 131 100 41 155 127 226 243 206 14 12 133 115 190 147 92 147 10 124 243 1 213 202 209 6 1 181 206 251 240 96 231 86 66 201 246 17 13 248 115 147 70 194 106 179 231 212 238 184 87 58 186 144 28 221 127 91 196)
#f
())
#(107
"indefinite length with truncated delimiter"
#vu8(49 50 51 52 48 48)
#vu8(89 36 160 164 137 103 122 188 33 0 54 120 195 2 2 69 60 189 188 235 128 160 115 12 49 135 69 186 246 123 156 228 56 134 30 113 7 107 179 152 24 73 49 10 237 215 136 102 210 59 73 59 164 44 55 236 232 64 68 64 79 67 102 77 210 100 143 208 226 204 236 150 172 221 184 215 172 26 115 239 215 130 217 148 194 87 179 103 220 158 132 67 59 9 173 66 131 184 124 214 239 39 198 75 115 163 63 255 155 200 3 20 113 42 223 84 171 220 162 155 97 114 44 243 142 80 157 225 167 168 97 0 96 91 214 2 244 239 85 17 16 92 80 177 180 156 81 251 151 78 158 253 222 113 230 184 56 88 223 71 34 142 46 109 230 238 217 25 70 240 60 75 132 41 220 145 215 111 68 159 220 76 170 37 26 219 107 85 132 5 64 179 234 55 155 166 34 10 110 167 95 193 167 22 217 31 171 67 107 239 136 148 80 30 194 254 201 202 37 180 1 60 160 102 228 166 240 147 191 63 44 15 239 41 101 177 74 205 68 192 50 242 138 242 13 20 47 238 179 94 237 159 59 126 51 57 211 154 45 32 6 150 84 223 39 246 178 87 119 32 179 41 28 127 101 220 120 96 30 96 136 230 200 29 157 223 194 7 212 116 114 180 254 11 76 99 54 64 244 60 143 160 237 134 14 150 36 51 93 108 140 135 59 138 87 197 92 49 153 117 201 108 183 225 194 201 27 164 164 190 197 136 217 24 55 215 105 141 225 79 253 39 202 106 20 7 230 203 88 101 123 154 158 160 80 190 222 141 62 21 216 161 174 159 213 187 230 245 68 172 10 86 233 95 88 25 2 94 57 33 103 219 54 171 255 157 199 226 47 161 237 143 64 52 247 123 137 188 221 71 40 85 185 24 210 65 96 143 93 72 160 221 247 43 151 252 203 141 92 187 251 212 49 118 208 148 156 72 85 58 214 213 100 18 36 76 118 61 234 236 249 42 232 224 148 50 200 113 235 46 98 193 254 15 56 94 53 144 254 156 57 38 79 0 188 16 217 40 13 56 93 136 226 138 82 33 153 169 16 139 214 215 111 125 13 18 88 92 143 102 113 7 78 168 64 93 43 57 109 165 168 109 17 21 45 126 216 105 53 232 74 220)
#f
())
#(108
"indefinite length with truncated delimiter"
#vu8(49 50 51 52 48 48)
#vu8(24 172 58 18 16 129 43 202 214 13 164 1 139 117 126 211 73 77 159 65 232 69 143 236 67 74 234 50 221 148 151 235 228 135 44 25 100 58 215 105 44 235 24 97 121 193 104 249 226 26 88 246 85 49 196 148 241 140 222 191 49 92 252 42 183 228 35 250 14 56 114 189 28 129 218 196 248 95 242 25 44 158 250 235 210 165 242 22 42 114 209 61 172 73 85 87 133 60 177 15 15 192 240 97 85 168 8 162 18 2 245 116 62 214 223 64 159 62 142 86 63 235 164 176 177 31 63 189 217 100 106 42 244 174 71 243 117 220 175 40 128 255 25 159 86 241 197 40 134 143 11 180 206 33 67 75 232 10 176 228 184 216 240 173 118 0 37 66 210 251 29 88 45 202 70 205 172 99 25 42 27 26 35 178 136 7 239 86 157 169 164 221 154 191 49 246 167 182 188 209 207 25 203 205 61 245 10 186 192 151 179 62 242 13 193 249 243 114 192 112 201 207 150 184 173 205 231 144 224 43 236 78 38 32 68 96 9 15 207 19 185 207 187 113 18 44 41 191 34 194 252 21 0 251 155 206 20 10 191 115 159 132 130 43 79 124 139 138 17 95 80 80 153 60 202 5 137 197 247 98 187 41 6 67 177 61 57 103 50 56 244 50 25 175 102 178 254 15 164 38 205 5 167 116 194 158 63 97 116 178 16 241 238 197 177 45 135 152 144 219 196 179 204 60 67 193 124 230 213 212 150 78 53 146 71 92 162 170 212 75 5 40 248 56 53 195 40 120 141 58 220 104 5 11 32 227 153 239 180 34 135 155 171 142 91 222 200 116 76 35 118 250 195 133 171 245 246 140 174 82 57 161 102 45 168 213 108 192 72 209 177 245 86 70 220 237 77 27 93 121 54 93 41 179 48 171 228 18 33 126 204 173 239 15 24 227 122 42 107 118 147 39 28 103 20 58 101 173 185 109 187 86 29 207 212 253 172 15 249 210 173 53 121 249 214 146 113 108 162 128 8 41 71 36 112 151 86 223 152 252 83 175 58 36 80 82 148 183 77 139 67 245 206 255 133 86 240 33 205 164 188 164 1 178 31 42 169 175 69 93 167 248 173 69 177 192 195 18 145 255 0 229 86 32 72 13 225 252 51 242 201 111)
#f
())
#(109
"indefinite length with additional element"
#vu8(49 50 51 52 48 48)
#vu8(172 145 74 216 5 164 54 16 43 199 241 111 147 241 118 0 245 243 125 83 202 54 27 3 39 53 64 248 56 229 178 22 202 179 174 56 101 42 27 35 178 93 181 148 131 242 255 240 10 54 154 128 207 153 211 208 179 157 64 166 108 188 84 145 33 60 71 245 234 1 53 131 101 60 104 238 181 204 220 112 26 111 253 121 241 137 221 109 108 190 13 238 78 231 245 55 202 61 3 153 199 237 65 113 187 178 118 25 192 8 116 82 39 237 42 69 83 90 127 112 104 77 41 52 203 165 243 95 96 83 10 39 239 157 249 161 34 205 169 8 195 87 200 110 214 86 153 62 184 247 0 179 117 208 80 167 197 48 140 206 3 248 110 253 235 173 221 10 209 14 20 39 32 71 229 4 188 18 20 93 190 220 127 208 180 234 229 96 161 219 6 136 255 16 0 180 218 38 69 193 41 183 20 239 114 17 117 5 228 88 188 237 68 203 238 179 49 57 152 65 41 111 241 238 157 201 38 237 208 79 149 151 150 83 48 122 92 53 155 66 15 172 233 243 182 216 80 65 149 188 239 153 17 251 37 219 11 179 65 142 135 55 5 65 161 96 197 60 93 185 1 220 57 127 225 95 155 134 246 141 172 83 201 17 154 106 81 174 96 0 87 86 71 127 218 130 108 78 0 19 178 114 251 43 2 158 170 143 135 55 92 32 234 150 38 226 80 146 125 150 73 246 154 233 229 84 182 249 147 173 9 118 129 12 60 27 29 181 39 94 25 148 232 240 102 201 152 25 15 225 22 189 226 18 182 241 26 126 250 108 118 105 95 50 70 151 205 232 15 170 186 169 122 158 38 188 76 12 251 44 66 190 32 33 64 97 86 151 26 116 236 107 22 202 153 84 195 206 236 111 57 192 126 155 60 141 96 164 197 115 17 213 234 30 102 191 207 61 241 142 60 12 239 14 122 121 29 178 134 233 253 221 209 67 100 79 198 221 226 40 84 211 8 31 160 165 172 187 78 80 193 74 174 198 218 30 246 105 138 32 225 210 193 234 106 159 103 228 212 101 142 99 247 85 14 132 118 156 249 215 161 242 158 191 40 183 42 178 211 95 127 7 158 173 113 171 252 236 87 111 134 45 189 50 246 144 99 52 56 70 96 191)
#f
())
#(110
"indefinite length with additional element"
#vu8(49 50 51 52 48 48)
#vu8(148 214 37 230 65 148 228 221 248 23 71 90 155 12 107 163 24 4 41 15 247 3 243 156 15 128 111 84 194 0 190 69 34 206 229 192 195 122 53 5 70 17 91 40 179 189 80 63 59 156 225 124 180 133 228 194 135 90 72 219 181 182 100 162 128 185 113 245 247 227 243 62 9 255 152 24 203 50 241 78 98 234 173 130 191 122 246 12 132 221 224 190 121 181 28 7 100 252 167 178 235 107 60 25 55 56 205 201 74 49 119 175 15 198 229 251 42 217 126 55 119 196 35 66 158 82 183 251 147 123 180 211 185 224 133 20 132 80 26 28 119 208 224 188 59 151 102 189 252 245 138 122 144 158 236 214 253 41 132 245 147 78 6 22 245 108 29 177 180 231 41 146 121 107 0 215 56 104 144 214 144 97 112 200 52 158 10 49 53 153 2 79 251 58 229 183 247 168 87 249 207 145 183 185 4 96 190 60 151 81 86 206 53 144 255 139 239 110 239 164 214 94 41 102 229 189 81 4 103 216 100 33 51 103 211 172 109 179 96 123 76 107 119 48 120 98 9 5 215 204 25 9 78 4 7 244 201 39 83 151 18 39 233 136 128 5 209 203 18 168 85 86 53 82 230 16 83 115 133 206 128 172 30 181 67 172 103 51 19 148 4 124 18 244 193 242 149 120 230 32 98 176 120 188 175 239 38 172 156 106 10 48 107 104 207 10 113 123 153 100 30 167 234 245 103 125 142 255 170 204 107 109 113 173 113 60 18 4 38 178 37 132 42 204 175 73 33 185 169 97 81 188 147 52 197 69 233 54 70 43 94 174 172 37 174 2 223 10 44 78 118 22 122 64 145 24 45 33 89 234 61 27 45 191 164 95 229 33 251 37 170 165 107 142 124 92 176 116 110 249 201 132 211 29 251 201 94 64 53 112 81 238 33 130 227 169 73 51 126 62 234 64 116 173 45 156 13 87 133 132 241 160 25 35 57 62 173 49 51 143 35 220 72 230 249 116 63 78 169 175 169 131 84 234 60 111 101 115 5 180 195 94 235 195 145 241 96 26 136 224 2 38 1 222 1 165 202 246 110 211 252 113 7 196 205 55 150 28 187 149 53 71 72 78 253 196 128 123 191 200 87 78 224 216 149 241 190 244 100 55 177 206)
#f
())
#(111
"indefinite length with truncated element"
#vu8(49 50 51 52 48 48)
#vu8(16 21 139 8 28 0 64 149 130 250 130 215 81 231 121 205 185 80 25 114 214 115 165 112 45 125 246 38 140 139 108 109 118 174 142 152 235 245 88 233 60 68 96 249 190 59 239 126 220 212 247 140 179 168 187 88 147 205 5 94 136 77 114 82 91 15 36 158 36 24 48 140 126 129 183 60 215 47 219 95 7 16 176 24 120 145 118 119 1 159 178 17 101 251 129 148 81 184 7 197 182 202 162 49 35 231 255 11 136 159 251 195 72 70 144 255 36 132 172 175 128 48 182 200 34 26 15 147 59 130 224 178 249 47 59 61 23 16 94 74 82 221 231 135 202 78 55 37 44 204 6 11 203 4 217 173 117 43 3 232 93 232 157 46 181 212 85 169 19 99 209 137 196 248 192 115 12 209 101 244 119 48 137 137 107 70 5 132 212 4 136 55 217 161 137 65 174 178 239 81 114 202 113 212 76 114 118 159 52 39 47 97 42 137 105 23 2 4 122 192 121 192 197 46 119 34 154 27 170 116 70 32 211 181 81 162 106 59 154 193 143 235 44 254 23 171 207 227 185 105 155 36 116 71 139 165 134 183 250 25 248 245 130 249 245 122 150 164 20 216 29 236 48 2 126 39 132 224 49 229 42 57 19 222 89 253 91 90 102 69 252 113 225 98 183 63 11 243 125 234 48 39 138 80 191 255 52 63 76 159 81 31 24 128 218 184 197 56 113 250 165 104 60 33 152 119 214 203 41 218 76 227 210 44 205 211 7 159 116 149 63 198 66 98 190 83 174 77 172 221 230 91 172 119 220 57 99 78 57 85 192 13 129 126 131 33 66 123 102 67 219 249 248 188 131 184 94 97 201 89 83 158 24 175 94 252 34 212 194 42 24 250 253 221 54 180 241 141 98 133 205 243 116 82 212 246 253 190 77 162 212 120 209 28 139 93 30 245 67 91 60 153 85 164 136 231 107 4 157 173 25 242 64 120 113 52 144 147 2 15 120 121 169 80 83 106 10 108 15 7 195 231 238 201 81 200 171 66 221 21 4 5 250 252 147 171 244 63 189 137 86 134 255 102 46 250 207 158 61 19 174 199 236 138 143 49 135 80 113 91 69 7 76 39 125 37 166 202 113 20 45 209 89 32 215 4 122 75 180 54 58 16)
#f
())
#(112
"indefinite length with truncated element"
#vu8(49 50 51 52 48 48)
#vu8(94 182 224 93 189 94 240 39 71 154 70 133 179 219 178 154 185 190 134 254 137 81 166 214 144 134 67 169 77 138 111 253 165 159 222 237 66 223 157 64 15 139 137 193 52 16 36 86 12 229 196 134 70 152 29 100 84 210 48 27 244 241 223 112 190 10 246 198 223 162 179 18 238 218 216 141 74 134 175 73 228 200 216 167 149 185 67 60 66 215 124 132 254 88 3 91 76 234 185 20 193 169 161 155 55 241 140 133 164 127 196 68 155 180 3 235 31 45 227 188 85 161 206 198 255 125 228 27 219 204 112 139 138 246 179 119 100 100 233 238 169 0 249 16 232 7 172 215 186 136 106 124 43 118 204 42 229 166 211 114 195 154 106 137 3 93 166 147 74 9 190 107 246 50 57 34 137 206 220 170 23 133 246 192 8 243 50 168 135 190 11 20 131 129 243 155 93 109 161 139 27 232 121 32 203 91 89 142 175 135 222 230 94 239 107 81 249 133 208 44 245 226 101 141 40 71 170 5 119 106 129 255 6 248 75 249 68 91 2 207 165 190 161 82 158 33 111 144 59 117 33 107 121 79 53 54 171 55 145 238 166 179 141 169 30 115 45 120 74 135 14 171 47 191 150 186 96 104 93 184 214 24 166 220 206 227 6 187 187 63 162 195 199 85 216 166 41 9 149 147 250 173 120 1 76 159 16 255 155 148 158 224 174 186 139 211 177 106 213 91 209 159 24 209 72 32 195 169 158 216 126 28 33 218 132 9 120 107 228 203 27 92 72 225 31 174 39 45 143 166 95 83 240 188 43 121 34 63 101 125 25 163 121 49 167 59 66 4 87 48 73 185 109 46 96 214 224 30 94 206 13 241 71 118 18 30 252 235 167 37 45 187 144 195 216 137 251 125 203 124 67 223 174 108 219 197 200 52 22 37 45 51 4 168 40 54 177 227 121 4 109 115 49 117 152 230 203 220 19 189 122 46 137 222 62 146 170 132 79 65 163 67 229 230 130 105 46 180 237 16 43 63 194 158 137 86 125 120 156 242 38 129 31 8 252 109 124 163 175 49 163 99 8 124 156 190 208 32 26 32 131 34 80 98 113 1 16 57 95 251 42 46 68 103 132 181 193 36 246 89 122 167 135 172 243 3 160 242 15 163 54 241)
#f
())
#(113
"indefinite length with garbage"
#vu8(49 50 51 52 48 48)
#vu8(212 46 157 101 173 40 53 139 102 59 36 29 205 146 15 19 144 36 127 8 111 140 179 96 230 234 251 239 196 109 140 211 229 142 201 111 105 29 57 152 31 250 44 111 25 81 244 70 109 113 187 162 205 253 175 253 133 100 100 86 20 97 33 41 94 103 46 193 75 90 206 22 178 219 191 202 157 141 44 157 156 55 174 168 89 140 204 197 110 222 194 170 48 165 146 171 245 66 225 143 235 187 142 7 91 17 102 22 118 224 9 144 2 37 31 174 234 226 53 87 239 239 45 142 194 29 113 60 47 216 95 77 25 67 24 249 118 59 129 82 28 39 8 40 219 5 14 18 36 141 214 204 96 179 103 82 209 125 13 51 85 8 3 112 203 206 190 77 115 35 208 34 180 205 70 61 229 75 239 100 16 39 244 209 189 255 203 35 246 176 202 59 239 88 129 34 227 89 137 98 156 32 147 55 188 172 129 41 5 77 28 240 92 5 124 158 210 102 239 56 151 145 206 251 227 179 134 151 200 123 131 98 167 241 107 194 254 252 209 7 169 155 161 183 118 220 248 49 119 229 3 73 153 205 86 253 24 78 249 51 32 168 143 64 192 238 216 137 179 186 119 165 55 137 56 246 200 240 184 34 231 244 175 206 246 25 130 62 120 149 101 222 103 167 163 218 174 75 75 157 86 31 215 54 30 208 0 254 200 35 107 148 206 254 96 9 92 5 22 243 238 55 18 185 211 220 134 132 132 60 6 131 136 29 15 246 144 189 130 221 41 225 83 73 129 127 161 45 182 248 1 115 116 86 142 18 125 178 145 21 221 146 23 255 193 28 46 168 90 86 48 101 179 178 19 114 162 23 61 192 210 26 15 128 8 183 62 203 54 182 5 204 23 241 96 63 13 123 163 177 206 149 89 59 119 181 114 236 204 214 196 41 124 96 191 38 12 229 254 7 114 155 117 0 90 156 202 222 94 225 154 4 230 133 73 253 146 110 246 41 248 207 47 149 100 54 244 123 237 86 54 175 239 124 186 188 180 252 156 148 161 144 203 238 168 44 121 81 43 89 56 249 167 70 177 214 81 189 110 25 68 179 248 130 137 217 195 119 189 196 99 69 126 62 31 205 223 141 206 102 55 216 140 175 197 63 166 163 226 7 128 24)
#f
())
#(114
"indefinite length with garbage"
#vu8(49 50 51 52 48 48)
#vu8(14 162 47 37 63 231 103 128 218 214 104 5 66 234 15 11 85 155 166 4 199 245 225 111 31 36 140 119 48 146 246 252 232 96 121 43 124 10 105 31 59 133 77 133 84 240 152 81 144 132 223 60 204 250 61 184 60 225 161 114 237 252 103 42 171 94 141 19 234 115 177 84 87 176 212 151 242 104 165 129 111 132 45 157 120 116 133 220 241 101 95 107 115 55 140 142 133 55 36 133 5 77 223 64 154 92 232 237 142 142 39 105 251 207 88 100 136 99 240 70 61 67 97 170 124 50 174 177 226 221 55 66 16 106 73 198 132 248 156 249 240 135 28 51 153 30 169 159 72 139 129 176 66 114 31 52 100 0 56 45 234 237 77 202 101 124 232 172 23 166 138 246 76 191 147 38 8 139 0 145 62 65 136 92 250 176 165 81 240 151 181 158 46 25 33 1 20 134 52 188 6 58 139 35 1 172 195 229 224 8 141 209 212 122 55 136 12 40 136 63 135 22 75 77 102 126 185 103 51 171 147 25 140 133 70 88 164 56 11 40 229 172 232 222 202 222 154 200 45 162 216 137 236 0 146 211 97 227 76 226 102 76 253 156 82 160 180 154 69 174 227 230 90 212 181 69 251 140 42 155 242 71 139 124 58 217 105 249 22 171 68 207 162 111 144 188 128 36 0 67 84 136 81 44 99 200 58 122 70 161 72 47 137 119 123 98 159 145 62 161 26 155 124 114 60 103 43 127 63 3 150 35 158 215 91 50 155 148 225 170 51 223 48 82 63 233 4 32 73 131 219 37 216 3 150 147 124 67 151 9 228 67 236 233 53 229 30 45 1 139 97 89 220 51 192 100 89 141 183 40 247 25 159 83 253 101 157 240 246 230 202 199 78 151 129 41 32 190 207 178 11 251 113 211 31 176 98 74 20 229 33 199 168 128 134 131 0 22 187 34 196 58 78 252 63 194 167 206 186 66 145 48 28 91 187 74 160 133 136 35 182 91 13 144 240 186 166 128 128 149 70 240 220 161 59 77 214 47 118 202 217 2 181 34 16 106 196 70 140 96 18 24 137 106 115 218 25 113 215 54 78 13 209 182 191 187 111 55 45 204 62 187 74 63 117 6 59 32 211 137 244 235 197 169 147 140 102 194 120 181 167 16)
#f
())
#(115
"indefinite length with nonempty EOC"
#vu8(49 50 51 52 48 48)
#vu8(34 182 1 41 210 101 54 57 251 228 119 203 163 240 126 28 138 111 5 165 238 206 209 208 225 213 52 172 238 69 148 156 65 192 5 154 44 36 221 230 53 179 180 193 27 95 33 38 235 103 217 222 235 162 6 123 23 84 100 33 201 112 182 246 199 43 102 251 15 201 146 216 234 28 135 27 18 86 169 156 251 252 191 117 178 251 225 48 226 232 255 176 220 27 87 209 156 42 138 211 249 68 226 124 179 161 78 180 68 200 75 34 39 218 98 22 16 211 86 153 7 255 254 88 23 8 172 9 220 193 13 13 72 147 191 70 241 141 229 190 42 93 221 252 171 78 222 198 150 92 166 37 156 112 14 223 17 75 220 134 68 77 210 168 145 237 17 76 82 71 26 116 9 248 29 164 144 80 149 2 255 222 42 245 255 174 166 203 201 198 163 122 161 137 24 1 42 76 233 237 236 24 173 222 97 184 180 247 97 46 49 47 70 106 160 13 223 11 39 133 20 32 246 25 1 217 78 252 4 115 203 31 92 226 32 144 115 94 173 63 225 142 126 114 35 78 247 88 252 10 109 173 202 176 6 186 84 22 103 36 9 154 168 148 45 127 58 217 15 126 0 49 212 211 236 215 152 23 206 231 160 128 132 0 222 181 12 31 15 48 88 157 222 35 175 9 144 104 61 84 99 253 45 58 102 30 219 201 204 121 104 16 152 199 157 97 41 29 28 34 91 254 42 29 83 17 29 53 22 78 35 243 225 207 23 111 65 210 146 204 8 227 106 112 85 47 240 17 76 216 184 234 122 143 224 97 91 13 246 17 61 46 48 10 20 40 3 19 43 242 150 99 15 51 17 144 163 63 4 13 94 141 34 236 216 178 170 4 77 40 13 114 229 154 152 40 110 114 88 53 33 208 117 190 44 57 210 213 195 92 151 182 38 213 113 207 226 20 235 77 219 154 228 53 51 82 246 99 78 10 128 227 29 30 237 58 220 105 141 150 82 4 20 97 225 219 230 58 179 203 185 146 184 220 50 202 10 181 232 226 128 177 149 133 223 35 49 121 36 184 136 177 132 22 241 49 173 177 255 195 12 126 67 179 48 165 221 173 207 147 14 224 38 162 40 194 250 174 191 86 120 238 90 120 103 125 186 115 159 215 231 153)
#f
())
#(116
"indefinite length with nonempty EOC"
#vu8(49 50 51 52 48 48)
#vu8(195 26 7 201 72 3 7 18 250 170 33 150 34 251 124 93 11 97 122 195 155 154 44 100 233 68 218 215 31 231 212 197 172 65 172 91 3 180 210 239 112 47 134 168 13 163 113 36 195 150 239 179 203 73 166 153 162 144 162 170 211 217 64 66 229 20 72 250 22 3 5 64 53 89 129 70 39 214 246 183 31 72 105 56 45 161 13 88 227 243 217 185 96 243 188 109 150 178 194 40 234 8 235 55 214 80 153 177 140 202 219 166 38 183 157 63 234 207 23 53 153 158 53 153 157 208 146 93 51 132 182 33 217 121 88 83 62 170 217 120 113 89 132 58 67 30 152 78 18 213 2 49 68 80 51 101 17 203 242 138 33 195 19 166 48 138 199 118 145 71 202 175 123 254 26 203 40 216 25 37 11 168 118 121 165 38 146 249 177 194 248 51 251 235 104 152 96 129 254 54 216 169 201 27 187 147 155 153 157 107 69 53 231 150 54 141 173 7 171 134 239 175 249 207 3 220 86 249 21 50 232 2 67 60 122 223 247 11 24 166 12 64 44 229 58 60 112 119 136 74 63 64 80 20 197 159 210 239 201 253 28 44 0 129 32 187 151 131 27 158 241 223 128 136 232 15 223 190 188 127 1 54 201 247 126 127 253 81 35 237 161 229 212 228 15 190 200 20 159 34 124 87 82 176 194 48 53 176 165 113 27 102 109 182 10 63 251 26 158 126 112 79 151 4 252 115 91 7 210 52 124 99 137 194 7 201 170 23 244 20 113 43 173 70 159 234 159 230 35 8 37 149 92 59 197 73 73 170 56 56 19 28 48 18 207 158 8 99 202 183 125 149 169 109 55 224 33 239 216 61 174 33 185 177 111 117 211 169 125 114 232 9 108 255 210 242 103 153 44 39 81 27 142 29 184 12 69 239 208 217 93 85 182 175 247 6 170 55 215 177 66 25 61 30 167 75 124 53 157 79 108 138 243 170 11 196 57 243 86 73 215 22 28 210 206 121 4 30 178 104 149 124 218 117 150 2 209 225 151 173 198 162 253 116 33 240 234 116 164 1 191 91 148 124 75 57 230 211 156 25 177 134 82 235 4 57 142 3 201 243 61 71 172 198 227 205 71 68 145 27 184 235 229 243 185 250 46 246 42 210 238 207)
#f
())
#(117
"prepend empty sequence"
#vu8(49 50 51 52 48 48)
#vu8(14 244 233 193 162 222 166 120 207 182 181 133 129 224 26 224 1 230 126 131 16 36 76 205 214 184 61 211 77 50 70 254 228 101 254 97 133 60 47 224 47 169 133 123 236 175 167 79 219 229 154 162 17 102 194 16 177 23 48 192 105 158 211 94 54 162 116 208 149 42 136 245 46 91 96 233 72 214 188 38 132 20 108 116 207 178 85 243 70 163 250 194 215 186 52 53 146 56 119 100 136 3 151 97 18 177 156 217 254 52 121 85 208 16 1 70 215 184 39 154 61 72 180 197 88 19 166 4 17 145 83 136 244 13 221 135 23 95 176 156 11 74 202 107 104 218 217 76 129 19 133 104 12 10 84 121 156 171 226 45 159 55 110 183 49 5 116 157 194 64 140 3 63 32 210 28 224 8 45 97 151 178 230 44 162 250 215 143 34 29 151 28 67 36 69 169 51 15 208 108 171 12 255 188 232 4 110 190 65 155 251 53 74 76 147 91 232 215 46 117 247 249 50 250 69 188 47 174 127 102 20 213 153 54 182 105 182 168 27 21 39 93 139 167 201 225 129 169 158 125 130 186 225 225 82 192 43 45 63 52 6 204 152 254 133 218 93 186 178 205 111 31 55 156 48 45 191 232 14 130 224 163 104 196 61 77 69 144 125 187 243 197 139 44 94 206 215 147 232 134 61 204 223 212 197 3 175 155 105 53 80 105 241 181 37 74 52 154 183 53 10 37 132 236 4 74 243 202 76 34 70 191 74 177 116 189 4 119 177 29 107 219 254 209 169 212 143 22 147 199 97 227 64 52 133 131 238 82 45 81 200 159 66 125 197 199 71 113 240 221 51 83 139 144 36 157 185 198 123 135 157 101 182 93 200 24 193 176 22 197 30 5 91 232 14 142 214 136 65 0 28 57 109 25 195 202 174 87 190 167 130 223 193 89 109 188 38 163 100 43 86 97 223 172 32 34 16 171 76 133 213 165 22 194 71 156 187 84 105 21 252 200 9 193 78 13 185 230 180 198 202 15 187 60 27 91 31 0 251 128 54 206 186 163 87 224 92 121 107 84 111 227 27 177 191 70 26 178 182 88 133 180 129 9 254 199 178 21 254 192 223 20 89 119 76 150 191 168 98 79 15 66 2 205 201 7 236 99 22 45 175 191)
#f
())
#(118
"prepend empty sequence"
#vu8(49 50 51 52 48 48)
#vu8(172 125 94 25 94 217 83 29 231 171 140 134 180 174 2 198 224 200 212 132 93 42 223 224 88 14 243 51 29 184 211 38 127 131 208 146 12 181 56 71 53 225 215 11 5 54 19 227 206 223 168 78 198 6 251 45 226 222 71 31 64 101 126 5 73 58 5 204 208 97 138 10 30 219 188 187 153 125 182 4 177 34 181 14 18 23 24 136 205 10 249 197 232 118 20 183 164 185 26 113 78 69 177 16 131 64 18 116 66 1 11 80 241 53 242 224 1 25 210 91 50 39 121 35 239 152 199 134 60 103 138 226 235 68 232 7 143 96 187 47 67 170 206 221 149 175 55 216 215 231 115 230 64 84 147 9 60 32 211 88 204 166 32 108 79 118 199 131 91 200 182 44 189 152 150 37 135 100 108 236 207 87 255 211 162 158 29 241 237 62 47 199 198 157 193 165 201 191 19 206 219 19 14 104 86 34 128 127 193 245 234 72 222 153 33 248 229 57 121 101 75 129 145 20 251 180 117 236 67 70 114 80 220 60 233 250 194 16 146 77 41 208 158 22 89 78 223 233 181 236 190 185 12 20 229 106 222 59 203 15 153 251 206 197 208 180 64 137 172 15 0 107 59 199 229 28 4 66 11 107 44 191 220 133 6 2 196 97 103 45 77 31 25 188 148 224 22 251 117 109 89 176 129 131 86 240 127 169 57 103 3 173 246 152 160 242 156 103 9 206 178 120 157 105 136 150 204 191 138 173 201 101 89 109 144 114 50 126 132 65 138 115 63 58 218 27 159 227 167 181 3 25 246 106 148 143 173 37 84 100 76 174 115 71 220 24 65 55 173 79 238 13 99 170 23 102 249 53 24 125 132 45 76 122 79 81 215 82 194 194 41 22 162 171 228 27 209 202 189 30 21 94 22 55 145 91 236 65 165 231 146 174 140 228 25 23 168 4 29 22 155 3 111 112 93 170 181 159 72 215 228 184 231 164 198 59 153 42 75 219 247 254 251 20 204 118 209 73 54 221 215 104 35 99 162 181 233 120 42 13 42 11 61 28 178 210 228 151 78 79 126 223 78 80 172 2 193 97 60 51 1 141 29 133 179 91 123 180 53 236 149 127 55 182 147 215 54 248 151 105 173 204 248 88 114 129 137 67 166 124 147 168)
#f
())
#(119
"append empty sequence"
#vu8(49 50 51 52 48 48)
#vu8(111 205 170 59 221 40 81 21 58 136 211 238 24 13 83 31 253 176 130 181 72 240 173 39 177 219 234 171 147 36 1 198 43 196 122 108 196 26 85 31 107 171 174 23 252 248 30 139 29 41 3 80 214 200 39 166 33 152 25 233 121 111 28 222 194 187 200 162 199 91 89 149 61 144 3 188 14 93 30 150 51 86 62 65 32 206 96 140 117 139 160 58 119 155 197 64 34 48 63 213 155 241 240 35 143 222 38 116 142 230 12 45 135 65 27 240 201 63 182 122 220 27 236 101 131 59 245 211 232 11 122 52 200 198 82 182 127 115 163 110 141 211 228 80 225 107 142 219 233 98 63 200 149 105 32 24 137 148 55 225 65 54 183 38 51 204 205 20 112 63 249 132 81 102 121 55 115 86 47 93 240 112 73 111 94 11 114 21 52 179 90 83 5 105 156 181 219 245 108 253 98 193 168 82 127 125 6 96 75 203 215 77 10 143 143 206 77 200 115 59 216 202 58 160 143 216 90 5 226 4 73 51 112 45 144 137 126 64 123 39 74 108 218 35 151 181 138 191 18 249 205 211 119 54 129 49 228 53 9 105 21 177 3 31 233 0 211 8 25 109 231 66 193 47 21 108 38 228 157 125 149 196 79 76 235 177 109 227 116 28 230 206 151 164 201 50 163 186 162 134 244 176 82 26 250 192 255 8 25 118 240 40 248 230 207 60 20 188 22 217 5 129 143 140 108 95 168 190 251 228 247 83 218 44 51 81 129 233 156 146 173 16 109 232 42 161 82 250 253 133 7 188 0 50 214 143 34 148 159 240 62 61 188 130 156 81 61 92 107 79 208 3 247 101 22 203 43 35 133 155 7 183 113 49 253 219 66 120 134 50 157 185 89 228 227 85 62 184 208 73 239 110 51 228 32 144 97 31 234 113 122 179 180 45 86 161 246 120 176 231 13 255 231 1 37 245 201 36 216 208 21 74 62 251 117 165 85 185 112 189 231 156 28 108 100 175 108 226 184 3 228 107 139 201 77 125 184 38 234 181 29 159 212 65 175 253 23 48 49 192 178 132 71 170 108 45 214 102 173 50 129 76 117 63 234 34 243 216 22 218 82 63 53 101 228 56 215 49 117 213 8 161 203 36 187 210 168 146 216 125 245 9)
#f
())
#(120
"append empty sequence"
#vu8(49 50 51 52 48 48)
#vu8(165 167 59 82 66 158 149 150 232 220 48 192 150 6 153 169 163 156 172 58 20 64 76 14 121 219 10 78 60 129 174 184 57 28 237 42 193 251 40 8 246 212 90 142 132 67 32 83 233 203 200 189 18 163 187 134 43 6 118 151 198 216 230 2 219 140 121 82 74 179 121 251 104 218 144 170 39 253 197 70 23 205 78 39 67 50 83 218 181 111 163 128 251 172 112 122 134 38 18 158 32 164 155 32 124 240 103 70 51 226 152 1 235 3 67 84 165 37 42 207 247 255 235 163 214 75 41 191 198 156 84 72 15 222 224 77 118 134 179 146 189 189 72 157 167 17 222 6 86 183 184 106 161 116 221 120 168 14 109 220 66 78 13 225 106 1 194 86 36 242 0 161 145 120 5 72 53 206 170 194 194 11 24 49 153 230 38 104 243 200 20 28 12 126 64 72 235 231 98 62 139 81 21 115 220 18 203 3 255 16 35 212 20 132 38 42 15 143 87 167 58 110 161 224 11 50 55 64 77 173 28 230 12 13 127 64 250 239 237 79 151 245 106 174 57 92 107 40 246 210 3 138 118 156 189 78 227 37 7 193 123 75 209 112 117 232 85 54 112 83 181 194 234 190 51 114 124 31 84 224 169 109 24 141 164 18 32 213 117 117 239 172 30 242 255 151 132 224 221 91 230 91 202 36 233 24 87 12 82 175 244 65 157 123 5 113 70 96 145 169 246 142 61 85 165 146 22 248 246 147 87 250 170 254 242 176 98 126 133 255 182 248 207 35 56 212 39 149 44 73 231 67 10 66 122 80 153 210 43 190 229 94 138 250 242 102 225 14 79 172 99 39 105 97 149 1 195 95 72 120 147 115 241 85 243 241 42 220 0 71 68 68 19 169 235 244 144 230 251 104 248 247 90 87 89 113 51 58 20 172 102 159 96 86 241 202 1 150 118 29 246 161 157 35 126 27 96 137 83 134 254 236 130 159 199 238 29 116 196 131 15 148 53 86 37 104 248 88 167 93 191 165 18 120 45 154 63 129 124 180 13 106 73 106 126 97 97 224 102 200 82 159 29 146 94 178 21 237 136 178 152 74 15 152 221 142 40 136 104 101 148 95 241 190 7 137 103 112 18 236 147 184 140 149 147 196 204 161 77 90 74 9)
#f
())
#(121
"append garbage with high tag number"
#vu8(49 50 51 52 48 48)
#vu8(190 245 129 111 163 177 95 23 26 245 4 242 234 24 78 87 211 249 148 116 234 98 145 26 170 50 85 163 51 82 147 225 253 32 6 248 20 200 17 48 167 99 201 198 92 254 59 208 64 232 49 243 80 236 123 76 81 63 68 153 137 156 5 38 56 209 91 170 188 19 201 232 252 62 123 49 47 134 154 213 87 238 67 103 195 128 114 162 201 136 98 80 193 67 60 68 196 206 136 254 101 245 102 34 173 51 103 41 209 98 122 249 65 25 168 31 80 240 68 157 2 95 132 1 238 23 204 30 235 182 151 198 90 151 202 236 79 211 230 225 181 175 133 79 23 99 168 175 229 171 24 147 84 28 31 49 5 202 95 30 54 18 74 225 169 162 178 26 37 47 61 127 77 230 251 224 119 7 116 107 48 62 217 132 24 213 105 76 158 103 210 245 70 186 126 111 231 22 32 206 55 147 237 172 212 119 148 138 208 154 168 214 64 239 145 200 126 129 180 60 29 88 26 30 214 98 171 83 69 20 62 229 114 70 45 75 136 41 55 72 150 79 73 148 51 133 250 171 59 210 208 103 199 54 133 34 234 157 170 19 112 22 254 6 14 124 91 86 26 110 78 14 110 99 57 108 68 191 185 59 169 23 216 115 189 44 227 130 71 7 99 147 90 251 235 8 96 113 38 134 105 200 46 221 144 72 170 150 216 244 249 243 41 216 162 127 162 71 113 110 96 209 34 83 111 59 148 85 137 124 6 148 149 10 159 96 229 63 136 56 12 165 204 162 51 159 170 51 152 167 102 98 17 50 103 31 124 150 147 205 47 2 210 30 122 189 51 36 77 99 98 47 220 21 99 33 171 108 127 199 202 126 252 86 226 142 197 33 72 71 13 138 221 238 214 152 252 240 255 139 208 27 214 75 91 91 207 249 110 130 219 216 65 97 212 239 76 51 57 203 231 184 44 54 181 41 7 140 205 111 228 41 24 2 158 197 215 182 166 159 92 130 165 3 100 224 64 223 246 158 229 167 176 21 230 4 171 67 170 70 105 29 218 213 67 219 251 172 55 133 254 203 32 152 23 208 52 132 130 213 103 17 152 250 18 77 90 69 162 158 202 225 103 10 17 198 199 218 73 108 177 13 236 100 207 232 7 97 247 107 116 164)
#f
())
#(122
"append garbage with high tag number"
#vu8(49 50 51 52 48 48)
#vu8(123 116 223 16 25 87 60 206 133 172 31 184 181 126 70 199 37 192 108 79 68 245 21 166 83 178 111 80 230 119 96 11 92 173 5 85 8 213 76 127 115 197 13 125 242 130 41 22 113 98 33 223 148 187 106 135 176 171 233 85 235 241 33 105 73 168 130 126 56 15 208 91 78 89 200 108 77 130 30 36 74 38 235 176 213 34 29 212 97 217 40 125 12 178 233 194 127 159 229 197 60 60 36 59 69 184 22 144 43 93 47 243 165 101 14 205 116 156 238 125 105 227 253 81 126 86 152 103 57 246 109 130 250 84 65 47 251 220 233 76 218 75 149 35 250 23 122 9 162 117 99 74 1 77 89 78 252 22 235 82 197 35 118 233 161 199 165 42 107 1 244 236 96 157 210 118 235 64 187 49 73 216 210 225 215 171 124 30 126 57 23 112 224 248 33 73 93 201 213 116 171 133 149 103 176 161 211 44 37 91 57 141 56 166 215 93 135 152 248 193 237 185 239 47 164 123 15 39 185 246 171 92 211 89 157 87 134 186 1 97 106 65 163 133 21 143 146 245 81 191 250 223 114 166 141 83 116 141 103 249 9 184 90 101 62 4 243 151 34 235 178 246 40 68 126 126 184 63 117 101 126 165 71 175 59 114 43 172 89 127 194 239 230 30 84 14 78 205 93 226 77 62 115 156 111 210 25 34 10 55 162 48 131 77 141 2 56 160 156 75 22 252 193 239 216 94 7 79 90 205 113 218 170 78 228 42 20 76 155 197 161 23 169 133 79 7 182 42 10 237 167 136 124 19 245 111 152 247 61 85 95 11 154 197 191 147 56 135 99 154 230 189 173 56 211 192 34 42 181 75 223 219 245 188 180 7 210 123 140 32 248 244 87 19 144 92 29 109 155 217 129 96 219 3 247 250 184 24 109 207 172 227 21 194 126 54 20 86 183 254 140 71 226 90 122 16 68 182 222 246 198 168 142 201 26 247 168 65 209 142 94 250 157 48 26 53 129 126 28 67 70 92 39 58 209 157 248 158 215 213 235 248 240 166 173 128 132 89 8 77 214 18 71 38 73 26 186 255 246 249 94 12 31 220 134 64 213 230 167 219 82 145 100 147 121 37 20 234 133 134 121 237 157 102 12 183 61 125 132 246 192 155)
#f
())
#(123
"sequence of sequence"
#vu8(49 50 51 52 48 48)
#vu8(219 36 160 51 182 241 241 251 78 67 255 152 176 97 43 147 197 209 153 87 145 76 178 28 167 140 76 198 179 173 82 66 193 63 87 83 2 202 83 22 151 193 183 60 176 111 27 125 41 208 23 34 74 31 46 63 239 20 201 122 238 130 144 216 108 0 146 42 240 178 232 47 125 128 16 237 153 63 169 131 202 119 197 219 161 77 73 27 50 215 219 148 197 107 220 17 89 231 67 244 129 45 115 177 16 59 173 180 115 159 47 138 29 75 101 212 182 196 63 199 184 63 53 192 243 15 13 145 119 33 156 19 59 155 225 8 115 194 187 9 9 198 163 101 142 94 27 62 255 18 176 169 140 57 183 166 176 18 27 36 6 133 17 55 70 131 78 171 233 80 214 30 0 128 204 202 49 157 254 13 127 227 59 40 172 125 118 40 105 27 229 33 31 46 26 224 43 57 74 169 200 139 26 217 62 214 74 240 235 138 243 137 141 170 152 211 132 230 117 23 103 182 22 135 165 165 79 106 219 76 47 167 99 25 86 90 82 54 37 63 175 4 151 166 37 166 45 249 39 52 121 158 25 36 100 247 146 221 251 184 246 74 230 95 161 254 163 227 208 196 218 36 156 40 113 29 181 67 165 136 73 60 93 32 244 43 175 136 18 179 180 27 5 156 123 186 130 135 0 224 192 50 229 94 241 198 10 26 77 89 223 220 45 159 16 249 231 46 36 71 114 86 220 149 110 204 105 175 69 100 9 199 0 128 90 224 240 78 159 212 44 132 3 130 112 142 89 33 77 220 216 136 224 60 185 111 45 34 213 148 236 25 156 84 22 46 171 181 182 92 236 8 71 53 144 249 194 172 3 67 2 57 30 27 46 157 219 120 38 59 234 57 57 146 164 62 161 189 179 87 16 117 213 110 43 119 248 116 255 252 160 14 41 30 251 234 14 253 203 129 58 80 131 228 183 75 16 102 204 255 94 122 119 250 65 104 219 209 77 222 201 77 82 56 22 172 2 137 245 40 91 99 236 228 229 170 72 133 71 5 160 61 252 198 228 25 130 19 159 172 24 247 228 252 8 147 149 72 65 190 55 193 140 79 155 31 137 28 43 136 17 166 11 18 238 98 179 8 85 9 117 77 159 51 195 11 168 8 88 17 104 248)
#f
())
#(124
"sequence of sequence"
#vu8(49 50 51 52 48 48)
#vu8(62 200 200 32 148 80 217 110 208 203 70 46 25 8 196 80 146 110 112 146 55 140 138 254 197 247 6 54 184 87 78 133 198 118 53 105 123 149 179 250 62 204 2 78 86 41 198 132 53 115 109 20 18 202 134 101 183 118 112 175 225 164 139 215 157 99 104 85 226 248 90 208 73 56 88 70 210 117 247 91 110 119 187 105 37 17 18 53 47 45 67 138 91 13 177 183 31 159 60 142 45 70 116 74 65 118 172 58 120 128 163 110 10 251 21 125 224 62 93 89 224 31 201 41 198 114 193 68 164 72 199 123 222 77 218 93 90 157 215 78 165 229 62 7 208 126 93 182 61 132 95 209 161 129 20 84 138 80 152 102 90 166 68 96 29 110 105 107 213 210 248 31 31 113 217 242 229 94 69 96 66 215 255 54 216 19 177 156 164 32 214 8 200 112 78 250 5 25 226 225 71 241 85 197 248 91 100 48 39 91 92 31 169 19 249 77 120 145 30 15 8 31 135 73 245 191 125 251 242 26 33 254 80 49 46 196 11 143 140 157 28 29 149 93 10 73 230 104 181 31 236 58 82 210 104 220 200 38 189 119 253 94 10 244 242 196 71 165 29 238 64 252 21 250 173 127 121 126 13 185 7 47 174 177 254 207 124 243 18 129 76 125 133 79 243 206 0 15 176 104 0 40 193 16 230 8 202 37 184 144 39 9 250 246 77 14 165 50 1 171 186 172 96 37 184 121 146 217 97 164 85 162 119 143 245 86 1 91 236 182 202 65 180 119 115 60 34 217 145 207 240 65 107 132 46 195 216 108 84 4 178 217 237 63 71 239 221 182 250 31 7 37 56 93 23 51 164 75 247 91 81 166 166 251 226 90 243 206 8 64 169 95 134 218 34 126 127 147 243 10 212 124 3 54 96 196 80 19 190 41 40 32 243 61 156 158 93 79 104 181 224 87 85 225 138 27 206 16 0 59 125 46 233 121 50 175 18 63 99 98 149 189 138 19 224 117 119 238 63 59 196 106 230 228 113 251 254 229 101 163 180 97 186 185 175 103 241 142 36 75 190 243 18 200 165 156 241 234 200 232 141 78 225 183 224 133 38 12 5 7 148 93 217 7 237 103 151 4 26 89 75 136 191 177 243 56 102 159 6 152 74 112)
#f
())
#(125
"truncated sequence: removed last 1 elements"
#vu8(49 50 51 52 48 48)
#vu8(77 84 229 111 88 125 111 202 242 228 62 225 168 239 243 62 131 63 131 217 28 160 146 208 181 54 208 255 248 10 214 123 189 153 38 231 250 232 178 178 33 91 171 198 120 230 171 185 22 221 25 179 92 139 172 249 155 57 124 142 243 100 185 215 91 89 90 77 201 240 125 61 74 89 197 47 164 251 254 167 129 90 33 150 183 151 24 103 200 191 147 23 5 190 143 16 109 21 14 113 189 127 125 101 38 134 237 230 132 173 219 10 41 152 122 34 70 39 207 173 33 48 100 193 209 214 207 172 146 248 143 217 253 7 3 167 71 65 167 29 67 200 2 152 4 252 172 77 20 245 216 89 27 21 238 179 223 245 186 101 75 82 28 49 206 207 46 215 167 0 20 199 72 249 190 202 63 27 105 186 164 251 239 132 0 136 140 91 53 74 143 108 128 88 118 117 67 89 39 105 159 8 148 225 9 178 26 237 78 165 79 246 15 178 200 41 132 37 178 240 23 219 68 252 225 79 110 180 251 149 117 157 121 216 5 241 19 73 63 125 64 114 47 163 124 247 151 224 59 105 55 23 157 180 67 138 120 149 231 66 99 169 59 162 18 231 65 14 23 37 29 95 180 159 171 240 92 20 44 159 70 73 212 70 23 101 42 88 105 73 99 69 205 72 36 90 63 187 109 234 210 172 231 27 127 195 150 93 230 231 11 229 3 178 250 149 59 217 252 118 245 190 112 192 247 217 135 163 35 248 162 33 184 117 200 5 40 43 110 181 138 110 67 67 235 60 170 182 43 144 44 147 16 229 106 213 15 180 173 253 198 143 17 233 191 148 215 100 16 189 207 78 191 5 221 144 211 65 240 37 171 24 43 184 234 14 54 87 146 136 246 39 77 71 198 194 94 168 101 4 36 194 225 38 130 174 88 7 143 107 245 176 119 45 147 42 167 125 131 124 44 203 176 133 110 252 197 100 162 138 3 254 87 233 198 116 136 155 218 84 180 82 56 139 168 55 60 188 194 108 116 231 233 62 219 156 223 107 145 210 47 237 208 20 241 21 31 138 89 53 172 100 226 139 249 11 247 29 146 216 65 90 241 81 39 219 253 235 152 239 128 232 65 37 64 21 100 21 150 243 49 207 82 20 237 183 216 179 222 193 248 176)
#f
())
#(126
"repeating element in sequence"
#vu8(49 50 51 52 48 48)
#vu8(51 147 166 69 26 166 95 184 101 96 168 208 28 117 201 148 133 190 76 243 99 228 63 130 154 116 204 173 240 42 170 170 133 85 56 83 237 28 240 17 94 213 53 133 128 238 217 134 163 222 119 154 31 235 142 78 30 49 44 222 208 130 74 14 27 86 105 66 45 0 173 226 215 125 163 105 207 34 128 169 155 156 244 43 108 42 127 48 56 175 244 149 153 85 92 217 84 144 100 216 6 98 92 7 122 133 70 140 93 54 252 142 164 32 120 161 97 129 255 165 247 93 183 47 14 177 157 43 190 251 94 216 106 168 10 130 16 120 220 66 188 170 15 32 107 249 113 44 237 159 24 133 58 107 36 232 11 65 138 13 250 252 111 61 37 247 172 79 32 179 5 253 149 156 137 114 234 194 15 193 221 150 44 14 80 78 210 61 34 49 66 95 250 90 140 224 164 50 22 240 122 60 206 144 203 80 58 206 58 77 198 228 63 78 185 169 58 104 160 236 202 207 197 48 12 233 74 72 249 108 237 209 23 155 41 73 24 191 107 28 105 137 239 72 4 189 98 216 32 168 233 255 192 64 37 183 101 114 144 247 79 230 240 47 47 108 110 10 86 56 210 184 6 174 178 113 16 98 154 183 143 29 75 251 34 34 78 140 160 158 71 177 24 201 114 187 211 3 128 36 33 78 13 42 141 147 156 224 110 15 19 173 96 215 83 253 98 178 106 131 249 178 194 138 16 171 107 142 81 18 211 229 43 3 37 142 223 15 178 4 221 187 225 39 14 65 234 229 76 127 146 194 246 92 210 135 170 215 110 109 199 114 71 17 236 3 179 56 227 246 204 185 200 200 89 248 120 194 129 220 11 198 26 153 13 36 65 84 179 156 172 254 71 185 45 127 135 82 51 78 133 155 87 150 149 26 179 179 160 155 178 105 222 40 43 133 48 160 24 229 212 241 84 129 64 12 15 63 165 230 13 13 20 255 69 70 89 140 237 127 115 162 132 104 99 156 218 8 94 253 80 153 193 35 120 177 47 164 6 124 22 120 193 109 9 84 244 181 149 74 72 194 222 171 180 246 148 193 113 214 158 126 253 204 253 24 136 126 121 32 127 223 208 232 121 130 74 185 145 170 206 93 191 202 176 130 110 232 244 78 251 84)
#f
())
#(127
"long form encoding of length of oid"
#vu8(49 50 51 52 48 48)
#vu8(215 8 78 157 80 243 64 221 65 97 143 98 54 192 221 9 248 110 225 133 140 119 226 159 207 130 207 136 67 17 17 237 208 37 211 204 251 144 3 159 91 99 21 225 234 242 173 173 63 89 31 60 212 160 238 73 32 97 167 61 164 86 104 72 93 255 190 192 32 148 126 63 74 7 248 43 58 91 71 151 98 56 103 255 77 146 139 213 140 25 9 111 96 70 86 246 13 142 62 202 158 33 143 171 33 211 71 4 83 99 72 56 187 82 68 74 225 226 187 188 85 59 17 46 195 163 192 120 91 179 5 17 131 250 40 255 37 85 132 215 91 68 81 2 82 28 147 118 237 145 20 232 79 122 34 222 64 33 195 52 231 218 135 58 239 109 178 147 144 58 141 3 205 238 195 21 11 193 137 13 73 59 65 142 210 62 228 223 38 49 52 114 71 212 24 242 1 192 79 250 219 171 254 164 65 104 70 33 231 132 37 185 245 230 223 232 153 119 231 213 218 136 114 5 149 133 11 94 69 134 51 124 34 193 164 234 243 93 90 64 180 119 145 146 93 141 219 148 113 222 124 135 86 181 191 190 26 68 6 133 211 201 159 201 31 115 163 52 170 45 43 112 113 245 181 207 250 100 58 64 185 168 84 75 114 90 30 159 44 43 198 42 78 212 45 212 219 36 205 248 15 28 251 142 158 91 91 134 210 0 181 185 80 222 150 219 174 80 38 111 94 231 236 110 78 44 178 166 53 244 147 14 11 56 209 2 143 135 139 254 162 43 86 172 201 82 106 242 18 150 160 136 73 188 28 58 155 159 144 104 109 74 4 38 221 137 4 251 68 227 64 31 205 111 163 166 37 168 82 49 132 210 224 63 214 211 65 227 188 54 91 181 73 197 48 125 217 40 207 30 64 158 125 96 161 243 191 236 26 149 80 29 50 235 121 179 140 181 12 213 32 47 18 222 7 212 102 83 29 133 224 198 104 167 12 238 6 12 195 196 105 131 203 72 139 143 121 202 83 17 201 31 43 144 200 68 111 205 42 88 213 97 119 9 183 158 188 253 82 52 199 16 52 137 196 210 252 61 123 51 135 144 78 3 191 169 248 197 204 185 213 179 247 142 176 89 67 39 61 200 169 64 236 15 116 197 145 13 201 61 168 28)
#f
())
#(128
"length of oid contains leading 0"
#vu8(49 50 51 52 48 48)
#vu8(192 143 56 223 17 151 92 120 26 247 26 154 117 184 15 137 202 121 2 64 83 59 64 222 3 99 177 149 132 151 123 65 26 219 178 166 153 33 245 61 10 175 224 64 206 150 214 53 107 135 158 14 79 36 235 13 192 78 184 179 161 158 245 120 3 53 20 198 60 224 138 1 229 179 202 222 77 37 174 54 231 193 5 69 12 124 30 47 43 64 119 180 146 163 178 57 97 201 196 6 22 97 126 176 129 184 165 97 106 116 28 48 221 239 153 230 252 208 147 76 74 245 107 153 203 72 212 65 157 203 92 13 13 181 202 187 26 61 209 30 184 235 237 154 99 3 239 228 185 186 157 0 1 75 114 160 59 5 137 203 246 4 169 161 63 34 77 101 64 162 136 28 24 3 112 171 158 44 144 201 62 92 155 181 229 138 9 38 182 171 117 204 24 193 36 49 196 161 115 232 195 56 129 112 168 203 113 0 25 58 140 100 79 242 116 149 217 143 202 10 95 13 73 202 254 97 140 118 156 213 131 23 7 200 186 234 218 243 45 240 113 48 99 130 1 115 128 60 88 219 169 206 41 43 142 49 139 147 254 163 180 13 117 186 10 5 112 81 46 20 141 158 132 181 83 94 167 14 202 89 228 80 170 5 55 130 255 142 95 252 202 20 13 234 29 191 205 55 173 139 163 186 36 230 8 114 117 233 71 193 122 100 203 221 132 136 189 111 152 249 56 133 73 176 11 51 137 210 86 237 12 96 67 120 93 230 147 47 37 193 139 237 92 5 39 186 70 101 47 86 223 36 211 238 150 158 16 157 155 242 60 204 147 89 96 54 72 216 231 176 100 4 60 153 115 147 30 247 143 209 7 169 223 113 40 54 43 10 212 207 164 73 200 111 198 19 196 125 153 34 47 149 0 169 85 132 199 70 185 29 215 41 169 135 188 93 231 198 187 146 109 82 8 25 69 169 180 42 224 97 52 124 22 231 29 145 166 85 49 9 1 141 21 159 167 252 19 168 208 172 154 87 177 50 188 247 148 127 25 224 68 65 72 23 55 40 57 122 252 222 65 4 22 177 54 10 209 227 124 186 39 98 247 225 95 242 255 254 238 46 9 208 59 131 172 226 78 147 149 227 170 106 15 233 125 3 94 33 49 100 209 200)
#f
())
#(129
"wrong length of oid"
#vu8(49 50 51 52 48 48)
#vu8(33 174 219 0 25 29 163 51 166 73 236 186 106 157 113 93 75 93 55 154 133 79 39 198 210 124 44 232 146 214 214 100 102 78 203 83 53 30 199 241 191 117 115 51 107 59 204 207 127 178 95 253 195 166 254 179 185 84 131 113 124 8 234 189 184 217 227 169 249 25 55 244 149 169 101 2 138 28 137 219 206 168 57 0 50 215 55 40 146 152 214 18 65 151 9 15 16 97 30 65 141 127 109 43 54 84 37 73 222 119 127 184 208 162 87 247 237 229 90 155 99 169 176 215 190 189 194 27 75 140 132 94 67 250 162 113 213 93 135 120 26 183 107 171 155 87 162 226 35 124 70 107 252 221 142 43 35 248 246 85 130 194 16 90 163 122 239 118 135 255 181 20 223 54 41 163 103 188 45 63 209 131 25 150 153 207 147 198 135 97 31 200 241 144 239 220 176 45 214 185 226 40 54 28 122 114 194 235 221 80 119 224 158 248 102 227 4 223 206 43 75 128 254 153 180 42 12 233 244 123 141 237 66 15 192 231 228 98 164 106 130 48 125 66 229 241 57 25 133 86 195 189 116 247 176 33 93 141 21 82 192 121 200 149 239 202 47 157 226 43 218 188 70 239 202 220 53 93 19 203 138 214 38 47 116 104 184 94 177 177 213 193 58 154 236 151 136 68 33 145 75 71 77 156 80 49 248 150 59 93 99 92 251 141 171 222 75 169 85 9 120 208 189 169 198 234 14 40 167 247 139 26 108 168 33 133 172 244 65 39 112 206 244 24 155 73 28 22 247 115 87 223 123 107 132 143 71 34 192 152 226 12 183 194 73 243 136 60 2 158 118 255 24 79 101 122 196 179 137 149 180 40 215 172 244 2 57 177 1 120 126 92 121 140 104 58 254 231 254 25 252 173 163 206 65 212 94 99 208 106 252 198 186 172 223 66 135 231 15 3 211 142 206 43 82 63 87 195 167 79 137 210 60 148 144 240 119 28 196 37 155 29 99 130 241 240 214 206 149 231 170 96 2 16 76 37 113 208 143 32 31 87 204 128 88 98 134 119 223 199 201 221 99 31 100 131 39 201 71 134 113 41 26 202 193 60 219 2 213 76 14 122 123 165 137 155 135 87 121 109 151 110 151 202 100 177 138 244 98 4 114 38)
#f
())
#(130
"wrong length of oid"
#vu8(49 50 51 52 48 48)
#vu8(55 42 43 17 138 219 138 216 240 143 90 29 154 211 104 140 133 7 89 26 239 145 34 251 41 92 122 206 213 61 60 205 38 133 74 52 134 36 117 126 0 141 227 109 205 209 54 124 255 123 251 201 71 118 231 98 165 193 254 97 209 221 46 248 210 94 113 76 198 140 38 81 69 107 254 49 11 44 97 209 112 188 224 125 45 106 87 78 182 164 252 240 96 105 86 214 193 138 37 64 111 248 12 14 21 63 216 215 141 236 102 211 25 163 16 128 144 97 80 168 251 211 166 181 164 47 200 52 91 224 189 40 51 91 175 252 222 180 88 21 3 39 89 23 112 105 123 247 133 205 193 119 74 52 236 116 11 158 215 111 56 109 148 26 129 224 191 137 2 244 3 82 103 151 236 91 213 5 135 0 19 27 212 44 156 26 66 167 248 131 168 85 146 103 159 30 129 100 127 122 96 152 31 181 208 151 92 224 51 102 212 188 90 60 218 18 94 109 222 65 115 180 185 159 103 78 95 235 11 148 172 21 228 34 111 24 23 164 55 97 183 135 26 130 168 208 181 162 43 48 195 150 158 239 70 145 39 187 1 195 248 190 94 53 222 73 196 27 55 19 202 32 77 117 14 25 26 90 48 63 3 204 214 122 61 63 193 22 43 25 124 221 166 207 96 75 93 123 54 194 89 48 245 202 80 41 240 113 67 143 222 31 148 10 39 5 92 219 10 144 47 61 166 245 127 40 174 103 14 162 211 213 85 76 153 201 103 2 67 134 131 91 96 75 15 211 241 72 171 8 28 142 121 218 110 164 103 202 22 241 76 147 134 145 238 184 49 87 77 211 94 238 151 168 172 229 122 250 205 31 92 86 77 177 120 202 5 127 89 111 95 102 127 231 166 185 56 7 92 156 227 177 16 189 18 236 43 163 184 44 94 174 13 18 182 191 25 98 73 107 199 225 62 76 224 77 229 161 99 156 38 31 149 98 174 207 143 135 33 24 33 1 11 10 50 178 138 76 214 184 193 129 139 62 162 72 181 241 26 201 234 147 114 18 31 48 189 222 85 242 128 19 201 113 55 97 162 200 95 229 99 197 140 65 140 8 8 31 236 252 23 143 214 182 76 107 169 58 156 189 46 125 129 187 151 17 50 21 107 3 16 93)
#f
())
#(131
"uint32 overflow in length of oid"
#vu8(49 50 51 52 48 48)
#vu8(108 111 64 20 198 234 92 100 232 104 33 90 73 95 178 232 5 6 84 88 219 43 240 25 135 212 69 117 137 213 115 85 130 198 26 229 100 141 147 236 55 227 66 63 114 19 17 185 81 75 167 213 156 173 25 254 115 23 64 175 25 66 37 82 56 137 196 81 237 219 94 225 175 155 111 62 141 166 164 57 244 144 82 234 4 16 16 208 20 63 42 190 200 4 176 214 177 189 26 3 54 232 225 191 58 167 75 129 124 33 39 18 246 73 134 44 104 102 122 191 87 224 170 196 123 109 3 222 59 112 153 199 56 70 105 175 208 181 218 203 174 75 197 196 214 179 191 82 223 220 35 196 101 213 144 77 107 99 51 255 104 94 219 239 31 156 219 229 145 43 79 205 236 108 107 228 234 119 243 217 19 244 123 9 18 58 157 58 250 72 194 49 69 48 99 236 156 128 1 48 239 170 254 123 235 127 124 206 44 165 227 234 67 82 158 104 216 95 147 177 19 146 233 145 44 158 228 182 223 37 124 118 208 26 24 170 110 108 217 208 33 215 208 208 48 156 177 139 159 30 90 47 48 151 46 87 197 195 225 42 79 92 55 104 11 193 209 191 104 145 29 191 167 149 83 217 147 215 169 177 151 54 14 169 234 158 246 231 102 123 35 182 235 16 103 216 189 186 25 168 125 48 44 124 198 39 164 190 181 4 134 15 23 184 159 244 227 250 118 0 217 171 101 27 247 27 250 189 137 22 96 51 207 181 88 92 182 178 53 99 145 189 176 108 253 3 74 159 191 70 115 85 238 145 225 159 37 169 205 102 180 84 86 181 12 129 51 228 149 226 32 117 55 67 116 252 171 29 55 61 188 82 213 124 31 56 34 75 26 238 80 200 240 255 179 74 113 130 34 13 26 223 183 128 84 130 137 215 105 12 165 194 240 65 76 128 227 24 206 12 98 163 183 75 121 60 52 183 8 241 223 161 248 127 237 109 14 229 174 24 19 167 232 129 239 153 176 243 192 223 134 22 189 225 170 173 133 113 225 6 73 123 86 200 81 90 197 59 210 72 121 72 157 112 23 247 249 221 24 43 90 203 73 189 59 118 186 193 43 167 146 11 28 46 79 11 112 90 153 226 156 147 150 60 168 151 209 82 50 159 160 151)
#f
())
#(132
"uint64 overflow in length of oid"
#vu8(49 50 51 52 48 48)
#vu8(223 136 169 214 172 88 68 37 135 184 109 239 151 252 139 11 213 147 75 132 28 21 243 241 187 120 214 132 6 10 216 213 137 145 186 205 216 104 128 190 1 225 146 29 42 7 1 131 77 236 123 94 171 28 228 214 241 28 49 77 76 210 143 199 234 111 182 61 75 244 156 120 222 234 22 236 122 211 216 7 229 125 204 227 135 242 27 100 60 126 251 188 179 108 162 61 34 255 191 204 39 174 92 1 154 153 116 254 21 67 202 27 200 148 171 240 138 239 57 226 95 70 52 235 4 244 87 56 98 167 58 255 104 59 164 42 139 243 68 248 132 0 112 223 237 11 174 23 154 49 77 35 90 105 48 7 156 98 178 46 214 160 217 69 210 55 131 42 254 145 30 186 183 114 186 10 182 248 206 112 62 40 173 245 137 237 184 54 177 32 243 112 235 44 120 195 74 159 93 98 88 177 51 243 80 210 17 210 238 41 85 166 77 12 123 223 83 233 87 171 28 164 73 150 132 255 130 138 165 27 132 64 21 191 82 127 137 218 248 229 79 49 81 68 208 202 66 111 182 123 169 101 169 47 231 122 175 66 41 6 9 235 110 231 217 192 152 180 195 150 51 122 78 102 123 170 80 236 252 33 213 61 67 39 14 250 232 130 6 244 175 187 88 233 79 67 186 66 255 59 244 63 246 101 232 78 123 44 103 7 213 27 113 21 90 115 74 140 238 144 45 85 146 126 27 192 32 231 33 84 192 107 250 230 69 23 113 66 176 211 49 180 128 34 28 92 51 85 91 158 216 48 87 84 50 25 82 141 17 139 126 102 54 93 157 249 235 56 29 46 49 218 155 15 109 141 252 243 14 218 167 218 124 61 210 21 13 159 92 82 115 92 5 114 57 149 211 72 199 191 217 246 179 128 0 132 140 228 236 216 233 27 68 83 0 163 116 78 69 59 243 98 71 223 18 14 93 240 249 104 109 153 251 154 88 71 251 234 139 9 194 182 64 3 218 242 67 196 110 1 113 144 186 90 127 124 200 163 200 211 175 127 52 138 117 126 129 79 103 58 134 128 49 23 105 179 146 136 88 44 157 51 222 2 178 242 12 239 114 140 188 157 233 98 155 96 2 221 113 248 230 81 110 177 240 0 225 113 88 233 212 7)
#f
())
#(133
"length of oid = 2**31 - 1"
#vu8(49 50 51 52 48 48)
#vu8(111 103 24 8 62 196 77 170 206 253 103 19 20 169 178 116 14 111 225 100 56 77 36 100 43 221 113 246 35 61 93 229 189 187 96 69 255 56 168 105 116 130 32 22 242 33 215 179 209 192 3 94 189 123 203 195 241 212 232 43 234 3 70 249 121 36 46 93 39 155 65 208 94 48 4 13 73 148 216 191 186 86 114 74 115 66 152 220 192 30 113 4 129 66 83 241 46 240 241 246 119 54 90 39 23 59 185 90 175 128 94 49 163 5 232 29 56 33 66 68 125 140 99 164 36 168 205 91 19 2 102 101 153 105 203 246 95 125 223 107 84 125 78 27 183 82 169 108 97 134 191 41 255 213 42 157 140 235 214 28 238 235 206 51 83 179 217 121 124 109 31 21 171 29 181 216 59 86 183 192 181 220 251 16 214 140 150 58 123 129 158 32 144 100 92 179 178 190 12 133 145 155 17 74 175 199 224 141 180 197 240 86 98 167 75 238 194 206 127 51 160 32 152 119 67 233 253 127 88 12 107 23 57 145 120 170 119 194 48 191 27 10 253 228 202 155 141 92 177 132 66 68 31 78 165 78 89 35 173 180 66 132 203 4 120 150 91 95 127 80 191 15 61 54 234 249 33 10 95 186 172 141 238 190 188 248 66 215 15 35 134 189 233 22 192 65 32 55 108 135 110 103 31 141 241 115 187 18 204 17 116 108 177 179 167 191 250 197 87 111 210 253 103 11 149 117 11 128 60 142 219 247 97 241 243 33 37 17 16 153 64 39 189 252 48 10 9 32 206 3 161 136 132 210 139 72 120 161 220 111 254 106 71 16 179 123 158 194 82 180 15 105 144 43 115 114 103 240 202 252 235 60 133 135 197 228 132 247 154 188 96 123 210 129 53 248 140 238 163 173 248 65 83 1 58 254 27 65 95 234 1 166 233 87 147 237 166 75 159 111 112 30 155 106 81 208 249 106 4 247 74 95 174 43 25 219 42 215 45 140 195 88 54 124 216 182 57 30 18 168 82 248 150 59 85 159 134 58 232 80 119 123 44 187 96 43 214 169 218 88 178 84 100 170 36 49 94 204 120 193 4 148 123 96 140 65 211 88 151 152 220 249 16 254 82 121 193 40 201 157 108 84 103 215 221 207 190 53 231 102 201 172)
#f
())
#(134
"length of oid = 2**32 - 1"
#vu8(49 50 51 52 48 48)
#vu8(12 123 151 27 98 198 165 57 160 241 194 23 253 242 121 111 232 98 224 145 233 131 144 231 82 151 47 238 135 173 243 165 65 211 198 86 150 42 163 15 100 26 40 151 43 208 31 32 116 19 63 32 119 71 126 71 79 65 59 86 148 184 114 98 42 23 152 199 118 208 1 215 106 34 104 183 176 0 32 35 110 149 180 127 109 204 131 228 96 116 100 61 105 84 93 79 128 151 140 75 18 123 229 238 236 93 200 125 62 88 32 67 42 35 183 23 210 118 232 106 180 46 185 200 123 234 130 246 2 181 3 109 107 40 203 164 49 70 11 223 71 95 44 116 16 77 17 85 207 128 4 240 131 221 37 122 237 112 72 66 128 133 167 195 69 246 232 53 155 241 154 14 110 125 110 225 0 187 247 6 227 199 129 157 66 125 118 146 15 13 237 141 141 26 36 195 95 24 33 152 235 127 61 83 189 79 133 160 17 23 93 43 190 98 145 142 62 2 26 18 115 168 8 187 211 99 155 235 243 121 44 160 246 196 181 65 36 71 117 151 104 21 213 161 249 137 255 217 62 93 235 28 206 182 29 253 16 161 62 178 173 107 34 174 110 170 139 168 194 91 246 69 37 223 180 64 129 60 91 116 134 195 54 81 173 211 34 248 51 72 62 52 225 101 39 197 207 92 216 129 165 220 143 117 227 105 97 10 48 28 101 101 96 93 207 12 99 25 148 191 245 2 135 44 230 46 216 90 134 65 47 228 10 242 40 144 100 165 81 255 143 94 34 167 144 73 57 137 51 166 213 223 189 77 82 90 198 119 129 253 198 128 201 194 46 64 192 185 42 141 37 132 44 7 101 112 169 131 184 82 149 125 255 49 54 31 207 238 41 117 72 187 255 146 190 18 51 97 214 37 58 219 221 12 13 139 185 211 133 70 199 157 89 193 249 160 157 113 27 193 114 142 104 235 206 57 141 148 251 130 68 241 201 89 213 79 7 28 50 30 201 166 154 37 94 16 166 156 82 29 154 26 113 40 246 17 105 169 98 24 69 207 75 250 112 7 41 227 30 223 185 203 154 1 206 195 104 130 161 211 31 132 72 182 59 228 217 138 255 201 229 19 47 23 27 147 96 76 131 248 166 136 223 219 186 229 150 213 99 33 28 54)
#f
())
#(135
"length of oid = 2**40 - 1"
#vu8(49 50 51 52 48 48)
#vu8(223 135 183 161 74 113 39 218 255 129 99 149 182 26 157 155 143 96 85 70 15 121 150 44 149 97 169 78 227 63 118 111 143 207 82 135 152 89 241 29 249 80 24 235 131 171 243 253 8 51 31 192 189 185 2 16 76 122 147 25 70 166 56 174 209 20 176 225 20 28 102 157 49 81 100 151 148 94 44 205 190 56 110 28 196 143 161 157 154 59 79 234 144 47 143 198 43 137 119 191 212 104 253 240 230 183 204 42 228 33 158 232 180 43 31 245 178 45 114 160 198 10 234 149 202 227 247 252 84 36 105 179 164 129 25 37 206 73 59 217 118 58 76 234 139 135 227 228 55 45 133 92 166 23 121 168 138 81 131 47 114 216 249 106 49 181 176 206 44 49 44 148 204 71 127 235 198 157 26 251 249 195 34 88 232 130 145 215 69 68 43 21 59 74 211 26 195 118 40 126 159 194 14 226 116 66 115 109 24 126 57 111 8 159 110 200 14 195 132 97 189 40 175 136 22 91 204 86 118 252 10 9 190 60 10 50 43 7 235 173 193 233 1 82 165 1 49 113 159 246 118 239 227 98 64 86 192 58 36 132 225 116 87 84 197 141 120 163 136 2 150 158 171 187 154 117 13 230 104 69 67 8 108 59 66 161 213 140 4 171 34 42 70 85 120 175 9 198 68 225 199 162 91 202 79 59 81 16 236 137 181 184 198 188 5 87 6 240 180 175 9 231 114 189 5 197 245 223 216 180 226 36 23 120 216 213 182 174 50 117 32 138 1 110 83 137 22 24 214 246 20 92 245 166 202 97 59 218 206 197 183 94 24 56 100 198 28 131 84 201 236 105 57 121 92 129 131 83 184 185 155 4 58 42 250 209 231 182 189 46 145 205 197 35 1 105 251 85 23 84 191 210 220 167 147 18 76 60 134 62 123 232 167 56 125 222 169 64 155 116 93 149 43 83 252 164 162 12 194 155 107 237 139 205 245 178 245 30 211 71 33 197 158 12 99 13 8 209 154 187 215 217 95 109 18 137 42 239 51 143 12 87 253 174 59 103 25 76 153 6 208 159 250 251 85 136 251 105 37 206 74 37 128 231 175 16 131 30 251 232 245 110 36 195 231 23 18 57 175 94 107 227 48 51 49 197 149 116 204 145 14 219)
#f
())
#(136
"length of oid = 2**64 - 1"
#vu8(49 50 51 52 48 48)
#vu8(156 87 0 183 215 34 168 241 248 63 209 19 89 253 227 42 173 22 6 210 8 52 167 183 184 75 34 191 52 177 143 92 56 58 52 242 41 182 92 86 247 14 19 71 99 42 181 154 117 130 30 166 35 208 235 192 156 64 5 192 243 42 134 225 188 135 54 137 172 226 183 60 124 132 185 31 226 112 244 87 254 162 0 5 30 4 30 255 114 175 39 231 183 115 118 157 55 213 86 156 2 222 90 16 20 103 187 176 20 176 101 189 254 199 120 8 35 232 49 153 163 32 100 203 33 73 200 234 56 129 98 247 162 227 96 76 124 51 225 78 92 191 181 78 53 151 112 64 38 222 213 103 15 94 253 151 157 203 128 160 181 190 202 66 229 244 158 232 10 238 122 129 52 141 228 97 110 59 61 114 61 212 250 94 115 193 245 107 217 179 39 111 133 173 138 206 101 79 205 70 215 182 22 13 142 205 100 14 130 52 50 160 116 212 190 240 171 11 88 160 221 20 148 62 113 11 127 109 125 35 171 255 12 200 85 183 233 50 161 76 154 106 13 85 13 210 138 125 204 228 96 83 145 176 173 18 139 247 142 248 181 80 24 124 64 66 174 137 87 6 112 88 123 143 31 66 43 18 179 203 32 208 149 120 138 139 49 163 136 239 175 230 22 221 24 65 203 69 141 233 212 88 41 253 21 151 229 94 224 194 78 95 108 199 29 25 79 224 41 48 220 55 31 18 67 255 164 38 10 3 18 159 0 40 30 128 0 6 156 189 200 112 31 70 147 249 77 102 121 128 126 40 148 75 64 49 124 231 96 184 172 23 3 144 35 58 176 208 15 78 66 241 229 20 149 12 118 153 33 94 46 44 176 167 0 117 162 46 85 75 8 33 8 58 212 93 99 235 138 219 84 205 0 99 102 92 76 177 15 103 158 163 202 166 71 253 84 136 187 58 248 121 162 242 250 204 86 239 185 120 128 161 104 163 198 86 196 209 0 130 105 54 147 66 83 196 127 135 162 100 144 229 24 67 132 87 34 134 43 85 218 238 172 247 11 125 169 142 118 180 151 98 125 224 96 171 59 167 18 221 139 249 225 169 225 93 171 61 70 116 220 50 210 255 76 175 155 48 248 28 130 228 195 2 247 40 139 118 43 32 92 224)
#f
())
#(137
"incorrect length of oid"
#vu8(49 50 51 52 48 48)
#vu8(132 220 68 30 210 21 161 183 175 160 129 94 161 95 64 61 160 181 55 9 179 39 168 173 38 103 123 221 121 145 11 201 49 232 79 110 10 154 6 23 175 114 197 191 40 78 225 192 90 160 2 157 75 213 247 32 68 4 213 131 120 181 21 7 70 9 125 47 101 4 86 188 234 14 255 112 238 29 19 113 168 179 209 69 100 37 43 207 101 93 83 154 102 99 67 136 57 65 179 2 59 9 80 1 205 27 5 171 69 174 179 5 123 180 15 143 193 16 1 8 217 193 186 79 204 187 119 105 101 186 69 165 169 204 110 176 236 253 35 11 10 44 77 160 216 222 213 79 18 242 144 246 129 135 140 207 176 44 233 124 128 85 242 144 50 73 123 135 239 236 16 226 37 194 4 49 90 220 48 146 29 226 34 228 242 254 42 146 249 149 21 38 147 249 4 135 0 170 18 122 214 81 228 250 143 106 172 226 36 149 58 67 111 219 162 116 112 242 57 199 249 165 155 238 24 14 44 17 75 126 67 90 99 79 156 180 221 244 151 23 236 16 233 93 184 79 190 236 107 198 251 9 161 15 97 60 109 138 233 236 49 93 185 71 253 248 241 22 37 98 53 176 38 135 240 190 162 199 6 99 126 191 195 9 137 91 224 2 100 187 70 35 72 213 36 144 60 200 177 52 206 82 244 7 170 140 135 26 130 155 167 204 86 138 3 184 3 54 96 58 245 239 61 85 229 79 75 177 170 211 53 61 244 100 94 169 34 155 58 132 200 48 146 223 114 176 173 90 108 160 151 44 84 249 193 221 123 5 243 184 212 94 47 81 97 188 92 50 252 226 207 154 53 187 85 232 24 202 38 124 10 172 34 90 46 59 99 88 125 147 145 9 69 150 54 91 49 50 238 214 206 36 41 159 54 84 149 204 96 41 72 12 43 158 53 98 216 183 190 143 240 26 180 135 195 157 246 127 9 237 105 254 88 110 177 135 90 199 26 122 43 105 109 178 54 32 55 184 236 79 95 113 135 33 25 252 151 91 206 190 2 71 168 188 21 203 97 191 186 71 138 111 23 140 30 233 178 147 109 251 220 11 64 138 176 86 208 78 152 72 167 201 92 139 217 176 0 19 235 138 4 95 50 169 174 64 23 85 122 35 64 12)
#f
())
#(138
"removing oid"
#vu8(49 50 51 52 48 48)
#vu8(116 124 188 88 164 226 86 69 35 196 99 88 210 16 175 148 144 193 221 38 121 206 102 210 103 4 53 29 25 250 140 203 179 246 110 50 160 102 222 177 29 231 220 145 10 55 244 110 37 14 15 146 86 223 200 223 92 114 203 222 99 162 178 171 86 27 29 121 234 148 213 30 132 208 160 34 85 42 126 216 228 87 130 46 140 23 195 12 114 58 213 196 227 51 224 135 33 21 102 207 170 225 48 231 155 176 16 59 190 9 59 48 241 129 159 144 140 86 145 244 180 240 172 227 216 203 202 37 101 78 187 181 6 86 6 131 250 212 93 138 73 20 178 66 183 43 153 162 35 162 192 163 171 32 72 109 44 209 176 172 96 180 56 216 204 165 236 47 123 184 56 70 144 236 78 233 251 176 5 179 210 234 33 116 154 184 108 233 214 68 20 233 168 120 39 252 145 119 241 165 175 108 217 127 184 35 135 75 168 46 159 245 48 147 250 44 5 86 108 99 228 199 245 219 186 215 93 130 99 89 76 186 41 73 17 51 65 250 199 200 63 161 51 80 202 6 215 49 119 36 27 55 147 247 128 39 214 26 32 195 124 86 233 243 79 255 218 114 88 0 75 2 2 161 41 105 247 24 194 120 133 75 19 106 17 13 253 101 253 222 169 116 134 120 107 213 120 95 162 89 107 253 110 120 227 83 180 210 142 230 67 77 240 132 74 241 77 225 14 254 45 111 8 139 43 62 192 167 207 111 158 74 88 48 215 176 18 60 174 215 133 125 11 113 254 156 86 231 44 41 169 8 187 163 203 153 72 33 120 214 74 78 39 151 33 121 228 218 96 88 201 126 100 140 131 14 12 185 107 167 30 221 193 205 244 29 56 248 82 161 101 84 243 217 130 26 236 87 236 133 6 240 188 29 242 166 48 181 143 176 130 200 77 238 94 123 243 182 69 201 136 126 101 0 152 80 142 162 136 55 15 159 44 211 47 195 247 71 132 200 47 196 43 194 160 154 239 59 140 95 202 245 56 197 14 18 173 198 114 32 7 57 203 45 187 52 59 21 89 191 112 176 11 47 131 237 49 57 177 6 206 113 127 144 107 109 225 120 192 217 218 102 150 103 130 202 211 247 114 125 163 227 41 80 175 67 127 51 207 20 232 104)
#f
())
#(139
"lonely oid tag"
#vu8(49 50 51 52 48 48)
#vu8(225 104 236 229 55 147 234 168 73 84 244 55 7 233 219 83 225 84 19 148 84 4 114 213 2 166 118 241 44 91 76 31 24 68 209 228 164 251 188 49 23 193 204 80 58 164 154 99 19 133 101 170 54 98 136 250 231 18 84 43 17 179 80 38 160 39 211 103 156 90 53 241 149 124 182 197 148 43 93 134 70 78 59 157 214 70 58 185 207 185 147 17 54 218 116 67 112 246 179 48 127 240 30 17 128 165 231 149 105 231 62 94 249 222 78 165 201 240 213 163 177 36 113 76 27 100 92 143 12 28 194 171 78 24 69 150 150 84 174 155 12 86 95 77 23 168 68 237 6 99 102 193 125 202 23 242 44 230 154 165 110 72 147 122 161 201 243 159 200 84 53 119 15 188 180 217 240 80 72 33 86 100 24 78 228 10 79 247 122 212 74 233 177 217 219 205 159 159 1 48 128 183 81 172 158 47 5 170 143 84 101 117 86 33 148 115 15 108 241 234 82 240 211 101 208 223 195 252 239 130 12 81 217 165 38 58 45 29 196 202 151 190 110 246 155 178 235 205 220 63 143 78 162 244 225 44 24 121 73 217 92 54 103 244 194 220 189 101 224 105 55 252 120 139 85 133 183 66 235 91 153 204 173 130 82 190 125 208 180 211 132 96 52 12 204 248 44 93 45 88 194 159 135 240 253 111 120 169 10 199 161 19 208 229 66 122 165 106 66 67 140 60 111 217 143 218 174 187 61 255 93 141 48 37 203 64 141 168 166 118 73 136 190 249 209 113 199 195 165 29 24 122 161 186 179 242 165 132 37 223 184 39 48 72 142 131 217 127 197 64 112 226 36 12 47 144 131 230 246 164 244 156 80 7 112 103 164 252 125 39 228 11 191 48 248 250 144 98 77 123 224 230 248 196 58 193 206 66 118 5 18 170 221 39 242 202 189 206 44 111 191 122 222 174 2 33 226 232 44 242 45 41 65 172 86 163 225 12 240 240 194 34 66 180 215 252 174 0 144 129 239 245 210 59 109 188 183 56 126 181 153 34 229 191 117 124 2 20 62 17 64 178 131 20 120 162 165 120 93 5 105 120 224 125 174 2 170 128 65 65 128 90 203 122 83 67 172 193 114 6 201 73 216 185 248 253 93 240 163 110 119 85)
#f
())
#(140
"appending 0's to oid"
#vu8(49 50 51 52 48 48)
#vu8(90 35 21 155 180 148 140 22 201 195 31 123 59 228 226 253 20 119 23 183 85 209 63 95 134 147 51 2 247 53 111 49 0 59 206 57 29 230 159 84 255 96 45 172 177 82 43 144 143 161 251 113 86 250 85 95 63 56 189 220 206 249 248 95 34 165 62 79 83 117 127 129 214 69 89 152 22 151 67 164 162 48 105 6 163 117 35 94 84 138 236 224 113 95 148 216 51 119 224 111 175 117 138 54 252 135 88 165 134 202 221 54 139 29 178 110 227 134 27 121 214 182 156 15 54 57 201 237 10 36 191 83 6 37 49 145 37 195 1 245 193 13 18 8 75 47 153 23 171 64 74 101 165 191 210 187 199 143 221 107 209 229 131 207 232 124 12 187 77 65 199 16 193 55 167 179 48 36 123 136 26 249 170 197 178 197 7 92 102 234 51 145 10 59 7 213 92 70 25 64 165 76 183 87 154 170 220 158 143 86 125 96 208 84 141 108 45 54 40 231 189 232 182 49 51 95 46 208 1 34 224 127 148 47 112 5 175 187 13 47 3 64 197 201 39 11 39 190 48 209 3 51 185 237 94 219 144 173 98 22 185 85 148 246 173 89 90 190 210 101 118 167 177 216 7 83 14 124 85 86 168 105 141 229 107 72 30 87 23 104 52 4 246 185 236 195 91 251 108 204 72 163 129 165 21 55 20 58 191 245 26 113 117 129 242 196 77 241 161 240 88 193 183 147 190 0 75 26 131 127 122 207 215 100 100 73 33 179 71 41 6 233 10 91 210 101 160 240 253 165 225 107 228 219 57 30 7 248 218 168 67 73 253 247 161 52 170 19 135 103 68 23 89 183 74 73 19 164 121 15 14 89 150 145 223 6 172 212 248 12 245 182 71 103 5 47 244 112 97 124 147 171 66 13 144 177 131 140 11 200 145 187 210 88 23 105 191 32 61 188 141 240 7 59 184 38 17 78 113 250 222 165 134 215 207 111 6 207 77 4 191 237 218 69 94 4 52 57 147 125 51 12 224 160 63 249 125 66 15 198 35 22 58 251 204 62 125 231 2 93 6 137 249 68 21 128 48 141 18 128 233 35 93 143 89 136 239 18 68 112 103 223 62 200 70 195 227 49 158 238 41 194 184 204 113 60 151 145 86 211 227 248)
#f
())
#(141
"prepending 0's to oid"
#vu8(49 50 51 52 48 48)
#vu8(129 153 38 161 199 160 226 131 170 62 244 44 234 8 220 56 147 252 113 215 41 89 36 215 232 144 159 70 206 214 114 75 243 141 19 117 65 34 73 130 240 114 227 154 128 203 39 125 171 141 216 72 202 133 254 28 230 161 2 232 173 170 165 95 46 145 105 216 9 79 16 40 8 41 195 51 45 36 80 122 84 69 42 2 106 84 20 70 251 56 138 118 99 238 197 18 160 221 247 64 46 253 232 89 250 22 98 16 140 112 74 254 172 128 218 246 248 39 158 90 181 189 85 45 187 90 10 93 15 53 250 84 49 232 172 54 218 242 90 94 54 224 150 153 186 37 240 15 166 158 215 251 82 122 73 251 37 144 142 244 0 171 156 8 11 115 197 244 212 29 150 90 177 250 161 71 47 118 198 61 156 195 89 247 150 77 133 77 143 141 179 130 195 4 87 46 166 73 138 111 126 57 246 246 6 74 234 51 105 73 235 21 122 35 70 151 95 26 113 225 193 138 119 171 205 12 123 194 241 171 106 14 146 151 209 33 191 19 244 44 202 86 98 102 121 71 215 15 188 2 111 210 160 60 19 83 227 76 236 96 141 194 251 162 2 22 50 1 202 219 99 65 207 128 244 144 72 245 83 51 219 151 84 197 254 149 176 18 25 238 182 8 202 62 139 137 13 247 21 1 219 197 121 51 44 124 166 71 156 111 195 195 79 49 86 28 21 213 0 202 129 242 82 4 226 248 72 248 124 71 44 240 48 181 180 14 73 158 63 3 75 232 112 65 221 87 86 23 63 31 39 149 209 246 43 215 74 168 23 247 44 168 161 49 176 165 183 254 163 253 237 50 186 244 147 135 31 11 232 37 25 112 251 43 48 49 18 44 50 142 120 9 19 157 4 77 143 73 230 189 49 250 147 139 115 42 93 220 0 57 167 35 235 126 64 73 29 117 51 9 47 27 123 125 138 230 138 221 96 1 23 142 209 98 79 211 182 96 240 175 24 79 183 12 112 156 120 232 59 29 191 21 107 44 136 72 203 152 97 96 219 77 233 84 193 42 41 216 132 150 40 58 60 243 122 205 14 122 99 216 97 53 55 109 67 189 229 23 196 14 155 94 83 137 153 168 110 85 49 158 235 217 168 113 73 168 26 234 34 90 129 40)
#f
())
#(142
"appending unused 0's to oid"
#vu8(49 50 51 52 48 48)
#vu8(219 188 52 182 234 214 200 85 52 120 73 83 194 246 255 163 107 1 143 149 225 94 12 40 178 20 202 47 128 189 150 148 226 240 145 216 188 62 37 170 211 196 201 225 30 220 215 59 103 133 56 70 147 228 204 177 131 85 62 238 226 81 197 88 113 80 186 199 187 45 124 113 127 214 69 58 114 128 52 67 200 55 34 96 160 150 89 109 164 160 183 195 39 80 251 38 78 213 138 205 199 54 200 108 131 57 107 112 95 211 172 192 243 215 211 19 93 212 181 118 114 157 104 102 76 177 225 25 102 67 143 8 212 23 192 219 139 195 123 2 1 204 154 192 218 249 239 96 185 182 0 206 251 121 194 81 4 210 253 84 128 194 226 172 16 14 149 0 114 154 70 118 171 151 224 144 120 115 102 150 221 47 81 207 144 255 150 58 110 233 155 118 94 78 15 124 245 32 148 80 114 148 222 96 28 13 70 184 126 128 114 227 123 136 98 31 157 202 173 40 206 199 212 84 74 226 209 181 130 139 193 172 158 82 88 5 130 9 148 74 184 233 36 253 34 138 4 125 202 3 255 226 242 142 136 244 157 239 137 84 1 186 63 5 195 5 190 170 16 146 139 122 57 14 202 155 97 183 62 134 76 147 85 154 50 149 112 60 155 216 38 100 178 38 188 160 236 201 13 43 39 223 242 45 190 99 95 63 10 52 124 73 35 145 4 8 12 91 129 149 235 77 117 0 85 136 157 88 83 190 76 201 132 242 21 187 73 30 42 140 123 0 23 1 109 203 234 59 153 81 238 147 94 150 125 21 21 230 89 186 41 95 118 190 72 254 172 28 58 238 46 53 211 9 172 113 135 122 229 159 2 77 201 170 169 226 5 62 77 66 35 228 130 236 63 177 215 249 202 233 140 24 219 157 207 227 7 234 105 22 241 55 222 206 9 99 152 160 166 42 89 77 206 64 72 88 143 135 225 116 28 206 221 236 49 77 89 96 251 236 170 232 207 72 175 176 157 62 234 219 245 167 126 161 194 121 5 247 174 71 220 240 102 32 126 98 30 137 46 125 120 11 204 155 174 58 182 44 190 42 76 180 59 102 33 196 127 144 77 205 203 231 3 100 97 238 37 99 222 31 96 97 194 47 51 165 228 153 122 223 158 99)
#f
())
#(143
"appending null value to oid"
#vu8(49 50 51 52 48 48)
#vu8(174 16 172 239 126 31 240 213 7 5 164 37 246 35 34 95 236 208 239 145 137 6 150 255 22 54 18 48 35 166 0 155 151 26 15 194 12 80 20 75 164 196 42 109 69 251 185 244 141 206 138 82 81 69 116 203 65 183 27 246 199 203 37 89 3 170 157 174 35 44 28 27 165 103 239 80 92 208 64 169 16 194 128 155 227 122 15 29 58 168 230 52 95 247 125 15 149 80 47 214 203 136 216 148 217 97 185 135 196 194 255 106 17 194 121 234 178 192 117 144 36 233 15 247 51 46 2 131 145 234 161 169 229 213 11 243 231 210 162 35 181 38 25 20 58 254 128 102 250 243 132 28 40 232 176 87 244 50 108 10 94 218 135 130 38 88 61 29 6 228 145 237 43 204 194 13 200 202 115 64 243 88 42 126 159 49 60 144 117 159 31 208 118 5 78 212 100 161 9 113 193 241 232 55 208 221 117 57 188 194 154 233 146 54 145 22 159 111 27 106 63 64 235 9 96 95 217 135 183 95 77 3 86 5 249 251 179 58 77 88 249 18 183 96 137 205 190 211 79 20 209 194 108 173 13 64 15 196 247 208 72 153 10 179 119 73 221 0 178 47 27 59 155 179 30 195 90 81 204 51 109 58 123 253 172 224 206 92 145 103 132 164 12 124 199 106 138 46 195 150 147 148 135 182 37 22 24 43 25 131 10 175 191 166 187 156 121 71 231 177 48 47 30 52 65 0 151 92 29 26 229 35 188 189 187 154 90 13 204 248 0 68 122 121 23 178 167 196 14 123 152 62 152 206 21 202 37 22 237 102 9 117 241 219 3 17 22 25 109 74 82 248 189 62 212 14 144 69 9 80 111 143 166 61 175 29 191 206 50 184 23 218 253 69 44 3 229 80 42 54 184 207 115 145 163 167 217 211 3 169 213 197 104 77 205 23 99 74 128 167 62 184 164 104 85 49 130 57 188 88 94 178 177 52 27 189 132 43 175 147 55 62 75 142 97 29 189 108 36 118 127 26 141 98 15 95 75 151 200 224 12 103 231 123 19 49 90 191 158 90 152 160 142 86 99 11 61 48 73 234 53 74 179 230 157 90 91 166 192 157 29 237 60 198 29 0 6 148 154 20 11 102 184 10 195 23 85 200 86 190 152 155)
#f
())
#(144
"truncated length of oid"
#vu8(49 50 51 52 48 48)
#vu8(217 172 245 92 156 1 203 16 217 172 246 220 97 231 199 190 103 52 10 197 36 20 202 177 152 184 254 171 33 74 86 27 30 32 238 95 108 95 22 159 3 57 131 110 251 233 144 68 234 103 45 65 171 167 60 196 14 231 235 71 249 38 46 234 66 108 181 96 35 43 206 93 209 26 255 100 217 175 59 204 169 97 32 127 138 229 89 252 226 75 51 53 120 156 142 195 46 111 71 50 239 1 54 245 156 165 96 249 26 170 31 230 213 57 2 130 47 229 89 210 222 168 211 163 24 169 76 228 214 251 210 252 57 156 122 120 192 241 77 112 228 77 227 186 192 79 54 104 35 127 125 69 210 205 245 55 130 135 154 109 206 149 10 51 49 65 34 101 79 220 224 21 140 70 222 51 217 145 185 9 123 36 253 17 162 113 143 96 21 106 255 178 122 206 106 136 15 4 104 156 205 232 62 179 101 84 52 6 251 126 120 38 152 111 37 41 240 103 132 65 173 160 176 190 88 112 206 93 28 34 208 198 104 75 95 137 126 190 235 159 245 131 53 5 206 47 211 82 181 40 106 61 201 32 154 73 4 131 243 96 125 217 7 0 110 24 149 179 207 136 127 214 87 5 141 153 24 232 23 15 64 49 246 222 162 139 115 184 63 89 169 78 254 172 1 113 106 1 40 128 122 118 120 96 234 65 122 230 129 245 242 188 98 124 60 157 230 21 132 243 4 150 210 143 203 143 154 24 39 110 180 136 20 79 154 220 51 223 103 39 135 29 53 112 173 95 105 8 80 115 163 98 45 216 191 70 52 136 29 125 239 170 172 14 167 59 58 64 233 139 14 241 33 78 137 92 29 68 156 5 19 123 4 64 245 129 100 28 127 155 224 199 199 24 160 140 60 138 101 55 252 168 10 179 197 240 38 100 68 53 184 115 175 107 9 138 121 45 212 218 217 20 246 14 63 13 230 102 223 88 43 12 34 121 199 134 168 45 68 242 191 35 40 185 220 166 169 45 165 184 165 187 252 204 107 156 219 220 116 21 96 233 145 140 166 34 134 41 67 124 229 147 8 11 41 82 175 52 210 143 114 251 238 42 245 52 127 188 234 156 81 121 138 218 94 9 168 216 179 219 112 150 23 91 90 68 231 0 86 137 180 157)
#f
())
#(145
"Replacing oid with NULL"
#vu8(49 50 51 52 48 48)
#vu8(94 130 161 146 168 94 176 152 193 65 57 104 211 160 229 141 0 132 33 11 100 19 85 167 74 27 89 232 101 25 20 1 121 32 233 5 162 144 156 137 207 123 59 9 127 254 188 52 192 100 87 187 150 71 172 57 75 138 13 181 220 51 175 95 78 149 36 140 69 207 34 197 58 177 144 107 245 81 109 211 52 76 12 176 32 115 233 158 190 38 126 91 54 88 111 59 32 207 9 15 60 149 18 191 27 255 46 58 238 186 187 59 156 50 140 151 16 57 174 241 218 134 8 240 208 94 249 18 128 56 195 80 2 136 154 242 244 99 223 86 208 40 235 15 251 83 9 71 78 127 126 97 1 172 154 170 133 77 86 241 161 32 88 130 1 244 250 131 98 81 90 38 32 29 98 73 176 47 85 78 124 42 136 91 82 11 78 195 82 56 123 64 167 186 239 86 195 130 132 50 254 237 70 76 18 101 34 92 129 131 231 129 134 148 85 243 97 89 37 146 151 0 108 223 54 140 45 200 42 147 162 134 148 28 19 108 98 147 181 170 117 58 5 55 87 168 203 219 89 221 255 92 139 45 113 34 50 125 137 128 43 113 30 198 56 198 183 196 248 131 15 22 11 42 171 193 40 217 244 16 75 93 121 78 204 53 213 215 119 59 170 151 110 14 252 121 94 82 114 254 11 109 237 235 243 19 126 157 4 8 91 25 145 45 1 28 183 231 70 177 12 173 158 175 80 99 207 158 28 30 55 198 149 122 114 186 204 38 31 177 199 119 121 93 22 186 222 231 220 11 223 59 193 38 114 244 216 129 158 177 17 187 210 179 172 123 70 88 217 121 1 239 12 68 236 170 231 178 29 155 4 206 206 210 94 80 4 76 105 96 5 115 194 69 65 96 143 30 213 44 107 47 95 235 6 132 208 177 189 168 88 70 127 45 224 183 196 5 73 11 201 133 129 125 27 181 61 85 249 156 204 133 230 244 223 227 114 155 67 220 110 57 221 182 244 112 229 34 33 68 125 252 51 111 173 10 188 225 239 6 164 192 116 31 247 14 82 254 148 175 16 136 251 230 247 202 34 188 176 160 151 227 47 61 198 64 127 117 125 128 254 52 91 202 22 63 13 239 149 78 11 88 33 27 37 9 166 71 189 35 141 8)
#f
())
#(146
"changing tag value of oid"
#vu8(49 50 51 52 48 48)
#vu8(21 240 229 93 44 153 31 112 150 0 215 141 78 74 42 209 148 150 173 181 91 153 197 246 189 146 244 96 17 41 87 197 68 116 175 222 31 62 117 144 138 86 148 136 59 156 231 220 149 108 40 248 154 166 146 182 235 187 210 135 56 54 184 174 89 108 145 76 17 202 183 62 99 51 242 170 197 217 39 120 217 83 97 17 15 159 74 35 240 154 55 53 12 32 168 133 13 177 43 82 42 132 147 205 8 87 20 183 153 6 37 76 20 238 87 96 199 189 65 214 5 204 193 6 169 71 148 152 139 47 170 130 62 57 180 156 130 138 42 3 186 224 108 87 221 182 117 240 250 209 111 8 90 13 114 10 232 151 19 149 232 163 23 119 11 93 169 55 183 63 251 42 29 134 220 96 0 240 211 155 224 60 29 192 25 143 95 49 33 50 28 27 160 252 72 12 66 128 133 44 179 21 25 142 232 106 59 41 94 55 22 10 162 197 232 112 91 34 173 150 49 165 26 118 120 159 252 183 83 195 203 72 2 253 117 99 218 118 184 174 116 11 215 84 109 141 198 177 44 49 141 253 254 210 211 243 83 188 148 176 171 138 28 145 17 83 26 33 193 175 109 132 34 235 97 214 252 252 119 249 131 170 135 239 133 119 167 55 188 9 95 199 102 167 163 112 37 209 116 57 105 118 140 63 67 137 33 159 70 96 249 147 15 76 196 93 98 209 129 205 53 209 24 183 90 179 176 19 67 59 82 146 52 32 79 82 189 13 173 232 96 151 134 174 48 185 124 1 82 224 90 177 177 25 195 248 134 44 30 177 117 109 255 204 213 241 173 137 201 60 217 70 56 78 97 94 44 113 47 219 176 191 22 206 181 194 51 184 142 46 188 43 70 30 39 191 228 75 53 174 9 236 246 183 38 35 111 69 232 177 168 245 111 162 63 13 216 137 165 209 50 68 140 4 206 34 93 124 131 105 90 137 27 147 99 159 50 20 183 171 118 65 139 10 37 42 89 90 227 244 230 219 212 224 215 41 186 183 15 253 58 49 230 232 216 20 45 246 247 106 125 94 198 15 204 200 240 77 63 121 11 211 115 189 206 146 224 249 42 245 188 144 181 183 218 36 161 138 56 200 254 232 243 162 13 211 3 181 64 221 100 164)
#f
())
#(147
"changing tag value of oid"
#vu8(49 50 51 52 48 48)
#vu8(209 86 200 247 47 215 187 84 19 200 34 243 92 181 141 195 155 248 150 15 1 113 178 191 4 90 70 219 147 45 64 46 99 194 78 149 74 70 111 218 186 54 104 159 237 214 36 160 196 76 2 34 88 102 146 20 20 144 155 153 174 217 121 37 115 96 40 174 72 191 45 220 92 220 111 87 37 122 250 164 107 98 36 165 233 103 88 73 73 60 9 117 66 189 119 140 93 162 188 52 6 187 234 57 129 128 84 144 39 214 96 41 6 226 82 51 192 120 183 234 6 180 175 105 207 165 134 12 166 158 176 7 14 204 82 115 219 140 192 68 94 180 202 245 101 175 104 70 122 74 36 216 165 195 31 113 78 248 44 126 250 186 49 58 180 79 76 212 246 221 220 120 246 4 226 221 66 128 42 185 246 216 40 228 61 163 220 223 103 220 46 94 19 155 181 170 92 148 69 137 246 245 123 30 8 65 200 111 206 118 21 139 29 54 131 189 192 200 248 92 54 31 3 18 220 75 14 212 86 255 156 103 0 114 82 15 26 19 156 73 215 13 33 147 42 80 120 48 100 215 119 90 219 187 99 143 54 194 91 44 93 117 175 143 166 122 181 52 64 80 136 96 209 222 36 42 129 93 14 184 127 38 146 245 200 236 186 69 83 128 182 29 200 101 49 48 226 168 81 16 83 45 246 170 57 187 225 52 218 31 58 20 173 204 72 168 231 242 130 225 66 237 52 177 254 177 25 192 24 144 121 232 30 227 90 134 71 34 69 120 157 25 59 246 245 113 123 95 218 85 46 78 181 71 179 81 139 41 41 37 245 13 81 175 220 53 36 105 121 110 44 157 40 121 26 116 40 166 137 37 175 209 238 165 40 170 94 133 176 14 222 179 77 170 9 247 218 101 196 159 49 216 225 32 82 250 34 190 101 25 24 167 151 237 239 102 252 89 70 213 146 111 33 49 141 138 191 33 220 21 22 59 247 246 48 3 124 160 85 232 61 49 203 76 212 125 109 68 206 129 73 31 49 130 82 200 178 216 10 234 79 95 6 6 67 129 43 224 33 150 223 49 231 60 53 79 145 240 221 44 172 191 199 53 1 177 216 213 207 216 29 101 116 204 91 224 93 203 247 96 56 25 184 31 111 209 177 29 208 211 25 140)
#f
())
#(148
"changing tag value of oid"
#vu8(49 50 51 52 48 48)
#vu8(46 189 236 229 186 142 73 79 56 16 201 143 73 204 5 193 99 105 186 51 106 224 53 17 35 171 111 31 128 243 253 231 107 152 188 217 247 150 67 153 59 207 11 238 78 5 173 109 147 80 114 156 78 246 21 151 180 84 187 215 22 168 80 34 170 156 154 14 226 71 27 253 194 46 135 195 39 8 108 191 118 227 106 228 245 95 191 127 227 221 186 191 80 231 68 250 202 238 211 137 170 210 245 142 141 17 211 85 178 99 159 56 36 4 147 109 136 219 130 91 109 232 122 234 163 120 158 236 81 116 109 179 207 125 185 153 143 248 150 26 63 73 144 121 17 44 79 89 83 91 136 150 163 11 77 237 223 31 246 165 46 55 13 207 61 255 139 127 59 49 100 206 120 181 121 70 157 130 50 146 48 72 134 205 89 108 81 42 30 229 241 137 228 14 185 98 144 149 101 61 69 240 86 131 181 52 4 171 44 181 174 85 246 75 190 164 205 205 0 62 248 12 60 236 159 36 232 132 47 131 169 146 248 1 12 185 150 149 90 145 165 54 44 111 210 198 229 122 129 245 221 161 253 185 49 202 67 153 126 81 255 237 178 53 216 67 181 144 162 83 213 191 57 95 109 185 255 35 58 246 138 26 84 52 157 215 203 55 53 26 28 179 229 238 37 204 121 241 148 3 236 180 30 65 237 220 2 212 238 170 182 66 2 184 105 108 167 20 148 86 255 0 165 99 232 162 252 159 144 165 210 90 215 84 114 39 99 216 160 75 215 51 109 215 136 75 91 87 125 136 1 123 44 198 98 20 185 208 213 105 38 123 67 176 211 183 68 111 49 207 254 75 55 22 27 160 39 226 67 83 210 214 58 51 156 143 181 189 73 90 195 65 224 235 134 75 200 236 37 135 79 101 251 98 117 83 3 26 88 201 50 222 158 153 51 10 40 230 90 64 102 206 175 65 32 209 3 111 70 181 207 244 33 6 23 150 242 69 202 89 168 151 21 232 99 67 168 181 47 148 234 206 50 62 231 87 143 12 215 172 139 43 108 157 83 241 169 121 207 200 99 83 140 29 138 135 191 33 208 125 113 4 151 94 199 166 42 250 42 85 27 82 6 210 114 156 218 191 63 124 57 57 107 186 18 58 32 122 3 198 104 106)
#f
())
#(149
"changing tag value of oid"
#vu8(49 50 51 52 48 48)
#vu8(93 2 222 207 247 139 113 41 21 26 102 217 58 83 213 1 255 60 172 130 217 38 148 218 199 139 104 51 176 136 163 136 157 170 173 201 241 2 27 2 182 210 238 119 162 9 87 69 168 64 72 246 6 129 11 152 15 113 93 24 241 80 39 235 233 245 146 121 137 93 102 139 134 209 76 209 192 86 211 222 14 30 125 166 71 35 73 222 87 177 12 188 250 44 113 206 199 189 207 150 106 230 64 123 204 144 179 170 163 223 40 2 221 112 190 69 157 164 231 97 43 233 69 152 219 182 112 38 214 27 243 248 143 221 1 79 214 241 128 179 43 120 80 55 163 150 151 2 121 252 38 192 230 137 207 71 242 176 6 144 130 81 220 20 72 202 244 46 113 225 155 250 6 104 215 188 68 54 209 30 105 74 221 8 216 108 193 3 22 240 123 246 76 84 80 143 240 88 255 215 12 36 7 74 190 131 121 113 87 224 87 70 90 17 41 176 113 46 188 45 51 17 167 214 188 130 38 65 26 130 76 40 216 206 129 178 26 38 238 227 207 93 232 107 174 121 248 32 106 189 201 54 152 133 13 20 31 197 75 34 215 248 22 90 238 223 239 168 163 79 120 189 169 186 238 156 47 251 226 73 195 62 162 4 15 227 22 81 164 171 57 119 167 31 54 209 63 145 47 172 92 218 76 30 211 103 80 166 241 107 178 224 151 83 93 228 240 25 72 154 24 99 76 64 54 236 115 163 169 68 250 69 189 30 190 7 62 13 60 54 197 54 52 5 56 202 52 159 250 120 14 64 138 79 16 218 10 166 192 28 59 253 196 29 64 1 218 189 55 157 80 24 76 26 120 210 121 68 161 188 210 93 193 123 54 236 200 155 171 208 54 101 2 155 218 204 58 170 140 134 112 158 145 246 86 206 113 118 162 90 103 98 38 66 165 1 58 126 77 105 6 248 195 196 159 153 142 157 86 107 98 64 155 1 109 123 239 182 168 122 201 131 177 120 78 154 25 99 215 80 1 89 145 43 165 20 248 41 102 189 165 142 42 165 202 19 200 36 76 70 69 8 195 235 17 233 70 148 151 160 111 31 150 179 196 89 5 95 109 46 86 167 54 9 181 173 249 77 5 135 163 30 61 133 246 67 185 188 108 226 223 40)
#f
())
#(150
"changing tag value of oid"
#vu8(49 50 51 52 48 48)
#vu8(57 234 146 134 13 118 179 115 198 234 238 116 251 151 248 67 144 103 192 46 38 224 218 90 26 133 228 102 170 157 244 187 193 242 182 68 202 190 84 82 178 105 43 74 163 150 210 152 231 169 229 99 208 60 227 187 101 166 66 114 249 3 150 142 93 219 161 208 227 50 44 144 200 8 39 190 236 153 53 9 79 224 118 129 244 18 65 188 175 173 224 162 167 250 105 241 95 133 46 196 87 118 52 39 7 90 212 163 225 41 194 41 215 95 194 136 180 98 161 113 60 141 238 16 210 162 113 22 142 16 156 172 187 43 127 20 230 37 0 116 9 171 163 67 109 30 204 7 76 145 75 147 251 206 167 60 81 50 89 28 245 3 120 20 237 155 247 16 11 72 208 202 164 31 65 94 215 49 112 114 9 29 114 3 104 113 162 211 33 7 208 36 128 187 193 243 194 207 175 64 125 14 178 24 208 3 219 211 165 60 10 76 234 202 249 70 110 236 199 65 186 119 99 201 18 165 148 206 238 186 235 52 145 173 118 3 203 116 245 119 37 103 255 92 151 140 157 209 163 245 49 125 149 116 146 97 139 130 74 68 81 85 209 247 253 194 93 201 59 93 23 198 150 121 107 33 7 10 247 140 107 180 239 5 91 14 68 243 25 175 66 53 218 167 155 134 79 218 44 244 0 48 192 76 18 48 231 33 86 80 67 230 255 144 127 23 215 177 254 52 150 30 156 134 3 70 29 193 92 153 105 214 47 23 234 158 158 168 120 52 89 177 53 189 137 67 168 225 130 91 252 247 234 232 67 117 103 40 15 99 3 171 245 169 21 139 174 67 11 21 133 194 27 43 229 174 24 158 203 94 197 158 166 107 151 220 29 130 71 100 30 32 12 27 91 140 233 5 214 176 149 192 160 2 46 250 112 112 23 55 133 115 235 48 159 178 4 193 216 91 170 57 204 243 172 104 65 103 62 26 168 202 161 149 74 58 63 210 216 216 187 239 148 84 27 203 89 49 114 168 123 142 90 39 249 66 114 160 83 186 95 201 64 217 5 115 25 119 194 14 5 15 197 134 77 45 171 220 155 7 201 161 81 41 130 182 252 251 27 217 174 74 75 248 190 8 110 108 159 137 4 225 208 218 63 232 31 117 104 82 233 130)
#f
())
#(151
"dropping value of oid"
#vu8(49 50 51 52 48 48)
#vu8(163 211 42 125 19 222 100 36 150 217 37 211 118 36 198 44 206 252 16 25 251 97 77 40 158 116 231 26 113 201 131 129 243 157 208 160 65 163 100 36 54 135 236 77 35 91 240 121 9 252 134 42 31 155 207 18 46 115 229 60 168 52 51 224 88 137 136 174 158 60 253 116 63 45 104 64 75 63 179 183 221 221 191 56 242 2 9 71 82 248 104 202 241 162 52 217 132 194 248 11 38 166 158 57 40 43 62 93 205 124 10 66 94 22 120 140 25 128 73 122 167 122 255 29 84 92 149 225 186 3 179 162 41 51 203 231 159 4 122 189 234 162 159 149 41 200 113 112 45 89 170 211 226 6 87 155 207 156 27 208 95 9 134 51 48 49 176 38 39 52 179 206 44 30 17 242 36 8 199 81 145 120 50 190 77 159 168 62 37 82 73 119 91 201 97 30 89 102 208 139 210 129 60 212 28 178 34 77 149 46 111 61 70 91 169 122 246 219 77 149 125 114 205 130 80 91 109 129 79 254 146 255 218 247 66 161 224 133 43 152 153 165 18 176 33 151 186 88 120 133 19 203 94 171 21 200 126 69 21 77 209 16 149 117 139 121 84 242 189 16 163 99 85 125 146 224 112 113 178 23 98 48 223 6 10 42 110 2 110 236 120 75 246 86 100 217 3 164 189 160 166 202 55 194 70 58 83 71 228 4 204 73 212 140 28 0 111 67 37 148 65 83 93 83 206 215 239 52 81 199 5 249 15 51 188 215 231 112 6 92 43 223 90 241 180 7 84 140 121 86 78 167 102 222 165 164 197 154 28 7 166 75 114 169 66 30 180 42 155 89 16 119 0 170 148 249 166 116 195 233 72 244 118 218 24 171 196 89 248 202 183 52 210 116 45 101 87 196 198 0 61 8 248 188 178 23 231 165 170 226 218 194 194 90 91 84 125 132 34 113 32 56 98 191 43 53 26 152 72 202 126 91 134 222 135 253 28 88 208 93 128 27 246 72 160 185 35 53 96 249 112 79 78 175 195 87 53 223 201 117 215 1 73 45 69 60 192 47 186 1 143 245 24 116 24 92 45 100 137 142 60 242 97 56 170 222 110 93 153 231 214 251 61 26 216 238 225 27 54 109 0 15 21 82 172 245 164 210 97 173 230 248)
#f
())
#(152
"using composition for oid"
#vu8(49 50 51 52 48 48)
#vu8(134 117 221 172 236 5 156 34 79 70 68 44 163 242 197 6 128 15 225 29 210 68 74 106 52 22 137 250 216 140 183 64 71 137 13 241 68 189 31 69 137 253 215 50 185 43 57 161 198 84 221 51 3 31 69 65 170 136 130 149 136 115 98 172 13 180 235 123 205 224 178 2 142 134 116 237 21 239 240 4 253 161 231 173 64 113 212 183 234 219 158 74 1 6 185 12 146 206 54 33 217 225 46 173 153 23 197 238 114 179 115 207 70 87 223 230 157 164 16 254 48 253 142 215 44 162 32 201 228 113 25 91 174 63 172 226 158 24 76 15 51 160 91 72 178 115 123 161 206 41 96 160 204 176 221 196 118 11 95 136 196 99 187 74 52 148 70 207 28 86 239 51 46 80 241 214 166 54 156 179 236 215 226 175 80 77 228 44 7 86 112 67 142 124 88 197 239 82 226 56 4 22 123 109 179 0 34 225 39 47 139 105 138 228 87 152 26 24 210 57 194 40 247 142 18 138 1 199 192 196 254 98 171 145 220 254 207 123 106 78 137 233 190 120 77 4 59 75 53 253 175 142 129 239 10 229 52 173 68 138 102 80 244 150 177 88 153 171 197 246 29 246 121 60 151 203 237 5 204 30 173 178 39 172 32 75 173 62 223 255 50 21 12 115 195 105 167 78 192 216 64 147 250 194 175 89 245 60 160 215 216 114 62 166 213 200 74 131 73 238 73 54 223 91 113 163 241 98 194 219 246 245 112 74 116 101 112 42 204 0 201 28 36 115 55 210 255 213 79 81 25 69 48 190 80 102 96 242 25 22 194 67 5 209 212 189 237 4 227 154 36 154 88 65 120 252 210 35 95 94 73 151 152 159 235 180 134 0 158 82 249 218 67 183 5 115 40 149 180 44 60 68 40 97 42 175 139 185 102 216 39 77 11 117 175 224 208 19 157 85 233 135 33 22 81 196 216 44 174 62 228 147 196 205 188 115 34 72 155 213 212 255 18 207 56 227 18 65 168 23 97 138 24 203 93 206 206 210 165 187 242 211 40 137 145 42 102 82 204 141 74 75 110 5 217 215 191 255 71 0 142 218 122 15 158 41 44 54 10 44 245 210 221 90 245 103 183 3 113 139 212 196 192 64 219 72 71 227 1 36 162 154)
#f
())
#(153
"modify first byte of oid"
#vu8(49 50 51 52 48 48)
#vu8(54 54 73 143 219 84 102 61 222 44 13 6 89 155 204 30 243 161 14 244 237 37 25 198 218 25 137 63 62 217 112 199 246 74 197 22 225 69 6 36 56 70 216 78 38 213 63 144 62 116 172 250 182 56 162 198 44 106 202 116 10 131 146 117 97 250 39 208 82 150 182 69 144 136 170 141 33 255 174 174 180 230 35 48 196 146 56 178 23 20 108 96 167 119 170 37 172 150 183 1 165 97 223 189 222 133 144 65 210 250 10 17 109 20 229 101 58 17 126 89 136 178 231 191 43 181 131 90 146 227 22 144 49 19 252 227 13 35 225 245 81 121 178 4 155 182 82 65 172 173 98 29 49 81 135 193 240 101 110 254 52 92 127 186 230 204 124 77 225 232 240 96 247 138 207 32 34 254 110 115 115 150 111 95 16 229 37 240 235 168 176 138 90 22 113 8 211 245 50 58 117 37 119 238 5 82 154 83 3 38 46 218 166 173 190 198 183 114 158 40 47 31 125 151 34 202 169 235 33 232 86 39 89 121 120 94 23 139 28 25 185 179 166 11 166 120 237 52 153 69 99 183 202 239 34 241 60 111 106 237 239 184 39 161 175 206 12 137 159 114 189 242 123 223 155 208 53 172 55 192 113 188 159 19 28 102 94 42 218 225 58 20 187 155 109 34 174 150 239 163 131 183 131 196 210 252 143 95 216 199 6 136 251 112 23 54 136 242 152 32 132 41 70 90 126 183 178 226 169 167 83 26 237 106 38 211 92 133 107 192 153 204 33 36 96 192 205 221 221 232 116 64 229 82 56 110 133 204 204 221 216 106 175 249 64 235 247 206 164 98 189 163 53 121 81 92 225 100 51 35 239 45 12 55 41 15 51 135 53 82 64 64 79 199 180 234 97 4 116 176 38 97 106 75 74 131 125 120 228 201 189 166 19 32 137 46 124 193 18 67 87 192 142 188 90 173 14 245 69 154 208 3 104 132 19 154 224 95 63 215 251 35 250 170 196 137 149 71 79 162 217 193 47 93 218 30 61 104 222 66 191 5 120 228 149 155 221 210 109 30 231 148 121 205 245 67 96 84 7 196 234 44 36 216 65 86 33 10 39 138 138 187 147 150 155 81 154 233 151 143 134 146 250 22 253 73 33 216 174 61 171 192)
#f
())
#(154
"modify last byte of oid"
#vu8(49 50 51 52 48 48)
#vu8(29 143 115 100 165 80 193 231 208 126 161 139 81 26 169 49 79 91 219 117 131 1 71 59 79 44 228 54 14 4 137 168 175 235 9 6 79 32 113 193 147 155 21 71 153 22 13 140 210 5 134 102 36 186 172 84 110 221 61 142 218 186 24 170 66 192 204 158 131 22 251 143 198 159 53 217 101 239 91 127 225 143 50 216 241 43 129 128 117 108 147 34 114 59 44 151 84 106 42 230 47 37 182 243 255 127 162 192 96 244 14 109 219 4 209 139 50 253 108 81 207 20 234 124 45 242 176 242 255 171 95 10 159 109 29 179 97 251 109 33 104 71 213 237 185 27 238 152 39 234 226 8 221 241 129 34 201 194 150 2 11 130 199 82 28 94 214 227 12 111 240 179 240 165 135 244 95 246 233 147 184 85 207 237 146 87 52 181 206 134 69 157 63 203 239 192 69 138 102 151 233 51 228 211 17 208 155 155 248 150 193 226 231 190 111 115 155 251 45 89 35 172 14 105 70 91 236 189 46 139 144 239 62 115 192 109 160 65 238 173 69 111 181 7 93 175 141 254 62 72 171 94 35 182 105 254 73 88 242 176 142 81 141 247 238 191 156 216 224 101 52 0 21 156 9 86 103 226 4 225 225 34 232 137 216 125 209 137 139 39 188 177 164 9 86 249 164 81 207 240 82 221 28 37 46 56 77 97 225 199 247 1 92 121 113 77 112 167 102 251 20 210 147 107 1 241 216 74 241 161 15 64 165 56 151 230 169 56 202 244 199 54 40 154 67 98 252 76 196 84 247 22 80 167 140 19 53 180 25 159 243 24 222 144 139 192 152 246 133 208 86 10 189 129 104 170 13 164 2 42 80 181 181 36 156 235 74 158 82 9 123 198 12 37 71 152 222 202 147 10 94 161 96 149 5 53 164 88 63 206 254 106 97 183 216 71 48 36 8 234 245 45 252 147 71 143 169 158 3 29 6 35 169 245 211 83 205 215 53 160 164 202 52 126 129 248 215 92 25 57 245 172 204 219 52 245 160 98 67 84 183 1 247 74 121 61 85 14 51 181 139 151 42 225 231 118 31 3 183 161 219 136 195 220 196 81 68 27 137 132 95 214 175 77 147 40 9 37 151 240 84 18 83 195 187 105 90 2 97 218 205 8)
#f
())
#(155
"truncated oid"
#vu8(49 50 51 52 48 48)
#vu8(176 188 215 119 41 165 235 56 203 83 39 167 37 249 60 77 90 172 57 232 251 30 246 50 91 134 37 163 124 1 160 15 188 233 203 95 21 0 5 161 71 171 92 207 249 192 243 71 37 119 70 208 80 133 225 75 234 108 1 111 213 110 121 133 23 238 147 207 153 17 175 50 216 123 146 223 97 34 203 79 33 183 93 137 142 92 87 37 83 68 248 117 147 128 196 74 6 175 82 217 23 148 4 79 28 190 2 44 89 252 234 118 249 212 246 146 137 90 138 174 217 142 120 52 170 0 240 73 101 148 176 86 177 184 0 39 27 101 61 31 192 123 216 24 133 248 173 43 74 166 3 0 211 15 178 155 65 96 32 253 200 144 175 84 112 144 211 7 194 3 66 131 254 222 242 237 196 255 69 4 87 206 183 163 209 68 66 196 193 100 10 92 177 182 122 125 183 214 226 39 37 132 9 179 106 225 253 82 209 38 245 155 5 153 218 119 108 193 204 150 3 135 190 181 176 245 124 236 224 33 248 64 42 197 109 135 235 163 194 134 126 64 70 168 172 217 118 155 157 129 100 192 208 245 182 40 217 255 211 196 149 56 31 52 189 129 183 60 56 188 148 68 27 182 46 87 22 9 31 224 157 64 163 202 154 113 137 127 97 10 80 26 177 115 113 75 168 1 178 32 105 210 14 78 220 187 152 0 36 165 134 46 25 166 0 249 187 6 87 250 59 16 190 5 113 8 23 229 187 131 136 81 125 141 117 151 239 80 83 175 132 168 86 193 243 255 64 61 142 47 2 143 125 190 17 15 30 244 6 178 167 142 138 250 34 10 143 244 68 72 30 204 209 231 159 164 201 195 142 69 217 148 47 202 113 79 186 2 109 157 160 250 60 4 122 191 239 110 9 14 57 185 115 233 121 144 203 133 39 70 14 219 92 73 206 97 211 102 159 39 217 12 196 17 177 108 142 173 220 173 236 213 134 213 93 35 118 97 130 59 196 235 167 7 134 49 221 196 153 96 204 235 111 106 222 60 189 234 142 67 102 29 40 255 248 110 237 105 153 246 254 216 183 106 97 79 159 94 10 29 249 211 187 76 229 182 131 141 127 190 204 55 120 2 92 245 6 152 171 176 196 36 158 154 239 152 114 15 139 163 197 74)
#f
())
#(156
"truncated oid"
#vu8(49 50 51 52 48 48)
#vu8(5 47 68 227 247 197 251 128 85 100 98 124 151 59 89 20 84 33 29 178 68 110 16 72 106 104 195 196 152 71 230 189 239 122 5 48 242 219 144 106 147 248 227 124 143 119 188 27 227 65 169 101 112 164 128 124 199 78 114 226 34 189 140 220 189 64 111 241 152 223 97 234 151 135 217 250 213 25 1 166 147 27 207 103 25 85 9 5 94 1 183 9 85 39 244 94 156 255 221 74 162 247 95 188 176 57 208 17 245 194 220 216 114 51 205 116 212 150 197 63 149 168 217 13 28 225 6 61 154 147 132 212 188 208 1 54 130 151 77 227 222 170 228 156 68 160 141 175 138 139 167 112 219 169 123 111 177 202 39 5 53 253 119 124 123 115 42 88 82 244 140 31 82 191 52 58 50 21 1 122 246 155 214 235 85 202 55 157 85 104 22 133 158 167 159 53 162 216 226 114 250 13 134 114 218 97 170 16 193 0 242 39 55 114 204 69 147 73 192 21 35 76 225 127 212 29 106 140 219 81 111 94 38 174 174 249 217 142 75 65 253 247 72 174 249 228 14 226 6 55 97 227 43 145 157 16 81 40 91 61 249 0 99 254 195 85 96 31 14 101 232 228 178 53 121 37 42 219 188 53 146 193 213 71 154 159 91 142 234 172 169 90 173 156 136 117 64 169 80 201 248 58 3 164 67 54 103 32 38 217 17 254 64 177 55 253 191 203 40 227 18 163 241 175 240 158 33 64 5 94 137 200 211 219 151 205 105 228 243 81 44 33 31 171 75 41 151 136 45 94 74 22 182 153 198 79 247 52 24 18 106 16 246 60 131 185 34 241 189 20 87 57 39 90 170 126 93 100 70 232 207 41 94 126 101 36 79 234 20 90 141 135 211 243 5 160 214 185 220 201 18 203 166 119 2 138 33 205 24 146 115 124 75 205 175 146 95 47 86 166 253 201 224 114 31 168 234 161 191 196 239 143 103 141 204 214 91 205 87 38 221 204 179 149 234 184 168 34 33 213 145 144 81 79 240 141 108 162 4 58 115 72 75 147 254 91 95 107 85 25 208 151 61 76 166 46 113 93 97 246 77 130 56 37 187 8 22 17 87 71 118 134 244 78 189 21 127 35 29 24 126 137 7 221 186 247 125 181 140 144 163 144)
#f
())
#(157
"wrong oid"
#vu8(49 50 51 52 48 48)
#vu8(109 215 61 142 183 247 175 14 111 11 253 205 132 161 7 164 205 110 218 238 60 188 80 177 55 66 110 33 226 96 143 244 70 162 255 91 173 178 223 213 23 207 180 124 96 216 50 192 15 134 225 66 146 199 152 114 99 60 38 249 32 8 242 102 70 114 162 78 143 147 71 195 179 121 64 206 134 246 74 198 152 165 3 138 253 151 214 84 89 105 167 165 192 62 129 162 156 255 93 252 209 192 145 93 242 136 118 108 100 131 191 50 185 128 230 11 7 32 132 121 190 24 4 106 204 48 80 254 15 37 222 243 205 99 205 92 119 248 109 43 208 244 25 37 220 120 129 225 155 116 186 176 50 59 43 254 246 29 168 148 141 119 218 201 104 236 168 246 106 16 211 132 115 93 87 186 222 176 207 115 141 144 101 47 72 81 45 5 191 57 191 176 194 57 222 60 5 115 81 156 16 103 240 143 236 207 72 217 40 232 227 102 51 228 128 37 219 254 164 158 254 112 218 225 24 240 207 221 44 245 151 140 184 246 61 246 171 137 243 158 19 206 5 230 210 126 177 9 29 128 59 90 98 30 217 87 88 254 69 209 251 36 152 17 115 94 126 26 95 47 182 212 228 19 223 253 108 75 149 207 16 111 127 118 41 176 82 90 119 199 13 199 136 34 207 218 221 164 70 129 101 46 77 27 175 136 49 20 188 85 139 78 172 29 67 194 112 19 101 213 134 52 41 241 172 113 104 78 8 191 62 91 186 254 220 91 65 155 20 139 45 81 97 231 99 169 107 99 79 41 179 47 43 67 218 188 104 179 165 17 54 87 109 245 226 187 196 15 49 147 50 151 28 143 223 103 62 43 101 198 160 159 185 129 24 39 1 234 245 175 214 187 188 23 7 60 73 214 166 222 58 83 156 84 41 244 142 204 254 147 89 219 105 27 6 241 34 238 34 134 65 118 191 165 219 246 252 107 77 107 177 204 178 241 13 88 255 185 65 71 75 245 213 190 149 95 75 45 69 237 247 196 197 188 176 96 81 134 173 55 118 162 48 136 82 20 76 230 157 242 173 33 110 181 219 114 185 4 229 12 123 158 37 168 195 231 193 66 67 227 250 154 145 6 149 97 199 125 12 81 211 248 64 8 245 18 3 41 73 146 100 51)
#f
())
#(158
"wrong oid"
#vu8(49 50 51 52 48 48)
#vu8(78 213 226 127 244 167 115 63 96 175 47 153 210 81 92 21 95 41 133 71 104 102 77 195 9 241 75 128 64 73 102 69 254 106 62 44 125 134 143 140 74 168 255 97 82 243 143 54 70 176 176 14 159 200 182 15 156 137 60 41 65 234 110 160 49 217 210 254 33 46 211 246 192 181 14 108 9 178 59 241 1 109 95 45 219 29 114 249 106 74 103 162 196 37 121 92 150 228 185 204 210 45 60 28 186 0 161 177 198 230 240 122 207 30 205 115 8 39 197 167 172 7 24 168 240 97 126 118 18 232 92 86 180 53 155 171 132 71 83 226 200 247 209 92 133 59 193 166 15 197 128 150 3 102 65 239 124 211 214 255 141 56 101 183 48 25 72 103 2 46 214 169 168 195 149 93 149 134 13 207 236 73 13 102 57 194 100 164 40 7 255 73 120 36 116 152 237 226 220 217 147 199 215 15 223 173 132 128 147 247 103 16 184 82 143 248 205 198 133 14 236 72 240 229 156 39 140 171 93 163 251 53 194 104 82 245 44 6 114 184 113 18 51 41 128 161 145 9 39 86 26 173 111 222 24 237 192 95 14 182 7 169 118 218 136 205 120 233 193 158 53 110 215 149 145 115 104 57 167 138 222 149 224 152 192 65 53 232 123 64 98 166 6 73 19 208 121 207 104 42 103 153 223 212 28 195 90 68 207 139 4 197 102 110 116 182 207 76 30 247 109 251 119 126 184 176 113 164 42 16 50 69 15 244 221 25 141 13 66 150 89 148 134 133 133 75 74 79 151 244 162 129 39 157 54 71 96 68 36 117 234 18 79 15 95 13 108 74 72 236 127 130 36 224 104 221 100 3 49 19 142 143 186 180 218 150 247 87 192 157 150 173 226 124 106 63 76 133 25 42 182 60 60 97 255 190 33 100 60 14 38 29 96 121 31 89 98 143 225 40 36 95 73 182 66 39 221 243 87 192 234 27 99 255 235 72 193 186 207 8 139 99 188 246 211 149 140 186 133 191 176 129 211 32 142 239 5 98 242 223 61 157 11 147 157 42 238 59 200 65 227 55 214 146 67 237 31 246 39 236 228 31 187 159 206 189 186 170 150 135 242 161 143 196 62 87 28 138 26 248 133 144 125 26 117 29 2 83 233 24 208 79)
#f
())
#(159
"longer oid"
#vu8(49 50 51 52 48 48)
#vu8(173 92 222 127 189 234 245 36 240 144 146 216 40 52 29 44 90 122 123 113 89 147 167 157 244 15 76 45 213 165 58 6 249 6 205 222 70 87 184 9 127 103 114 252 195 104 80 53 25 203 175 36 119 247 39 206 122 18 222 94 110 185 241 221 183 113 228 133 125 177 133 101 10 207 17 218 46 146 195 147 178 109 194 110 98 48 53 140 15 22 82 6 220 101 71 212 68 251 235 19 92 63 45 115 231 140 228 237 181 100 214 117 86 207 232 45 110 16 193 139 105 217 190 179 51 46 164 247 117 212 53 100 37 174 89 178 37 183 147 207 233 22 98 230 202 98 104 127 103 52 178 245 61 92 137 68 215 217 33 32 48 65 188 150 205 74 137 122 133 200 69 193 225 31 67 129 13 20 178 241 158 117 175 95 174 213 102 100 41 141 3 77 56 85 42 202 241 34 140 91 49 123 22 222 168 219 225 56 148 47 149 173 181 23 236 188 148 115 72 164 96 227 34 166 237 95 100 189 185 97 75 6 14 181 246 118 199 21 30 137 209 13 42 246 69 61 208 86 49 96 193 65 143 31 10 131 63 197 78 133 190 142 26 104 155 93 163 18 8 154 77 212 178 238 87 94 220 216 204 178 213 234 105 197 73 190 191 131 110 143 6 151 39 165 121 32 117 148 206 227 194 194 11 248 177 18 151 247 237 157 91 4 216 69 207 205 160 28 1 0 42 130 118 102 253 136 218 59 164 217 103 122 165 71 239 220 229 50 120 10 162 182 114 205 5 242 51 212 171 14 56 173 151 51 89 107 46 99 141 231 94 149 255 82 137 157 115 162 107 34 93 18 154 114 9 18 82 25 243 75 165 197 95 35 159 46 141 249 119 96 161 120 115 135 14 113 21 56 114 123 228 237 14 28 36 184 156 100 6 137 225 234 109 116 26 108 114 184 67 199 160 97 49 174 166 192 149 224 60 44 196 52 55 45 83 59 203 72 232 5 221 252 232 88 209 146 80 129 177 53 91 206 109 174 122 104 44 68 81 186 141 43 93 184 20 167 168 232 132 106 29 92 218 104 100 23 169 78 58 63 130 165 131 201 104 109 182 223 110 208 134 162 92 213 239 236 191 199 137 155 117 121 128 134 170 167 91 231 28 176 56 222)
#f
())
#(160
"oid with modified node"
#vu8(49 50 51 52 48 48)
#vu8(152 203 197 189 71 102 142 26 245 255 81 229 200 16 205 220 165 10 164 44 170 96 47 0 0 206 241 184 149 47 138 161 69 162 35 47 170 82 143 150 37 238 142 237 18 165 209 179 115 176 246 180 40 52 196 93 33 215 127 130 75 70 4 32 121 173 56 75 152 188 106 142 48 48 82 163 171 74 247 87 180 87 71 41 123 2 52 113 48 223 222 229 117 188 158 227 119 150 200 43 135 124 160 214 23 184 97 208 251 174 31 208 117 203 114 80 204 203 18 170 45 45 136 31 24 90 143 233 176 201 20 254 30 197 93 124 168 151 239 197 130 207 18 198 182 36 230 132 170 18 222 42 212 17 229 253 75 47 149 207 198 102 80 219 149 217 33 230 107 220 145 6 8 108 6 76 207 113 100 216 186 228 42 124 58 4 129 152 15 65 114 195 136 36 194 56 26 69 122 120 174 13 133 98 45 109 214 35 22 92 136 31 162 242 147 118 213 132 200 113 121 80 147 115 168 122 56 183 130 242 239 149 20 42 198 65 185 244 103 95 142 50 176 32 77 11 252 253 164 61 42 4 228 219 70 118 225 4 182 84 94 216 251 124 147 41 43 235 97 88 174 153 128 129 234 141 173 230 122 38 248 186 69 79 22 4 195 15 157 144 78 134 83 83 2 98 212 119 57 255 97 93 223 128 128 243 167 197 43 236 166 193 176 200 23 8 222 158 88 122 82 61 209 94 42 248 229 141 105 23 148 81 63 130 32 107 216 163 130 22 60 153 43 223 12 92 237 198 42 174 82 8 54 177 73 212 241 164 28 145 20 71 174 146 30 165 94 224 106 151 13 15 205 161 219 75 115 67 247 194 160 208 213 227 78 170 192 133 124 117 163 8 171 136 21 147 24 59 89 142 14 255 243 110 156 188 89 83 170 252 131 199 210 5 98 49 105 209 45 198 173 227 91 231 108 196 184 243 193 106 57 43 154 55 95 93 12 21 45 233 58 133 143 37 54 146 188 44 106 44 12 217 223 193 77 108 167 80 223 90 253 217 135 124 30 133 150 104 151 67 242 107 176 242 147 23 59 151 136 40 163 245 40 113 149 21 182 99 194 99 109 196 218 227 198 87 228 175 194 161 6 91 83 201 122 152 93 201 106 188 139 110)
#f
())
#(161
"oid with modified node"
#vu8(49 50 51 52 48 48)
#vu8(9 123 16 50 249 165 26 104 175 127 232 215 83 8 120 72 68 246 180 57 30 225 177 102 235 215 51 58 96 234 249 35 57 27 62 106 92 69 61 208 165 198 219 25 223 56 204 28 101 225 226 191 24 52 146 247 27 43 71 231 182 68 44 120 5 83 16 65 50 199 189 186 128 103 21 130 101 183 115 115 83 16 100 15 169 239 214 234 227 50 65 147 122 146 119 46 158 12 243 192 172 159 27 239 128 29 87 218 149 14 163 92 131 187 155 65 40 129 237 169 200 10 197 27 208 137 186 108 59 158 195 62 199 26 209 123 245 204 209 67 69 40 164 139 98 77 12 10 136 202 157 83 25 117 72 155 206 112 8 144 158 242 149 234 175 220 35 157 72 37 57 210 164 199 128 28 237 75 215 115 1 52 18 182 127 151 180 60 248 85 169 112 92 68 43 53 164 191 119 40 251 8 167 111 200 210 11 96 207 186 84 71 173 80 193 106 121 189 245 160 48 145 190 80 65 90 121 41 78 165 211 114 254 44 240 51 250 4 110 99 236 54 9 131 22 38 221 33 249 73 47 150 143 121 120 106 167 244 167 245 109 244 237 192 163 85 228 136 219 27 52 143 109 236 247 63 70 124 16 110 240 161 214 147 229 152 67 222 102 101 26 89 231 20 254 89 251 65 255 147 221 60 84 209 136 89 104 135 188 254 145 64 150 35 0 48 38 29 37 143 3 72 222 163 175 100 105 146 124 53 50 196 224 12 21 185 163 192 121 94 184 189 86 17 200 112 28 49 139 113 106 59 237 83 9 33 7 215 146 233 83 125 202 109 124 245 160 11 41 122 106 182 24 34 213 20 159 78 138 149 231 139 10 151 209 184 8 17 14 8 160 105 24 56 80 98 236 58 137 68 73 44 163 206 31 86 134 231 118 34 58 62 152 120 164 229 62 181 38 104 220 119 64 39 138 238 233 121 76 113 143 63 245 239 204 105 203 167 238 192 127 203 81 67 48 58 188 179 12 5 249 199 171 92 238 176 11 184 72 165 166 166 212 23 80 252 73 246 149 198 237 52 110 92 127 121 160 110 80 253 37 49 194 191 139 220 146 184 43 179 16 91 185 133 224 161 238 165 36 247 160 69 196 169 20 117 102 28 11 139 87 141)
#f
())
#(162
"large integer in oid"
#vu8(49 50 51 52 48 48)
#vu8(64 43 163 238 182 254 62 120 30 40 91 12 244 246 89 194 64 173 197 248 124 45 132 230 209 4 58 189 233 122 105 13 247 71 174 203 95 171 136 9 166 43 248 110 248 64 15 171 166 128 181 81 26 25 59 201 99 224 29 171 122 176 135 177 202 6 81 192 250 224 75 180 146 128 103 152 17 85 216 69 0 130 178 208 79 247 241 198 172 124 161 235 44 4 74 167 175 71 44 81 31 60 176 97 222 55 102 134 82 88 227 99 255 162 221 94 109 150 197 254 50 37 76 108 8 180 224 117 100 62 195 187 220 175 203 103 69 84 102 189 0 94 217 135 77 141 67 154 55 171 63 251 70 148 207 165 140 202 5 5 132 69 174 112 208 43 48 166 127 208 211 120 201 174 158 237 155 2 198 15 154 181 74 134 73 182 32 22 130 104 94 162 172 138 162 68 218 49 6 107 31 244 31 146 162 85 132 1 88 253 142 90 79 23 182 229 83 149 51 28 130 49 131 210 82 220 236 120 51 235 172 33 196 167 22 96 104 21 165 175 100 20 0 225 127 144 100 79 92 108 222 121 237 243 71 48 237 107 61 88 121 93 2 241 222 220 107 231 33 236 186 226 229 147 140 216 186 116 92 88 35 11 254 27 96 236 101 94 77 127 134 102 126 160 87 190 2 197 74 18 240 254 218 104 97 18 202 249 33 246 122 254 55 68 21 93 40 219 85 242 227 64 214 108 130 179 207 166 38 107 25 172 207 136 150 36 192 232 234 198 251 160 93 151 177 237 227 71 44 45 78 144 105 138 125 18 203 12 240 37 146 47 74 251 81 27 157 214 159 51 92 121 164 198 38 108 224 200 245 224 3 69 47 106 189 23 143 171 193 224 39 226 46 179 106 253 97 5 130 193 144 69 129 175 139 22 94 27 190 203 72 168 92 254 200 187 150 85 11 182 135 75 26 74 168 210 67 59 48 154 143 166 128 116 169 65 222 121 128 161 237 72 0 209 211 206 90 199 212 17 82 246 201 148 57 244 135 150 206 160 177 89 122 222 251 253 3 75 111 201 71 135 152 47 233 96 224 116 231 78 205 247 201 25 211 193 48 158 197 57 229 166 53 41 160 66 253 80 184 96 73 228 73 49 164 190 244 152 74 207 81 55)
#f
())
#(163
"oid with invalid node"
#vu8(49 50 51 52 48 48)
#vu8(93 204 79 90 145 180 180 178 189 24 156 188 62 134 93 3 91 52 160 244 19 212 219 243 163 191 173 24 37 15 80 208 188 116 96 167 21 130 30 172 42 248 36 243 22 31 179 209 151 168 233 221 92 14 228 98 225 224 76 225 208 243 168 16 26 186 42 204 100 225 32 242 71 194 105 170 60 177 16 242 139 90 201 239 76 235 134 105 183 20 30 34 38 247 61 12 39 75 35 141 167 173 89 181 216 107 167 49 176 44 227 75 9 92 147 104 145 53 69 7 207 2 202 43 140 100 167 161 186 116 42 129 55 82 134 50 84 67 143 113 147 232 82 253 25 46 73 63 47 145 10 149 222 106 240 42 234 183 230 35 215 202 134 184 145 77 64 252 149 99 41 151 220 139 65 85 2 106 252 201 79 25 55 15 160 171 26 176 248 124 143 224 104 28 222 238 113 250 172 63 110 179 127 126 209 94 121 93 33 211 128 98 102 158 43 43 232 238 154 18 18 100 93 60 13 171 151 234 102 130 234 215 210 37 95 109 35 167 157 14 137 81 2 222 117 208 121 39 180 77 20 8 192 133 242 115 138 249 148 248 42 217 183 129 11 16 170 22 29 220 144 205 34 173 111 96 211 166 29 185 141 237 66 226 10 62 23 135 198 93 157 152 4 180 170 13 93 115 205 142 9 128 0 0 87 81 113 180 229 123 61 14 146 131 13 221 202 12 194 104 165 71 233 160 250 4 136 193 45 130 249 55 154 212 178 111 36 114 228 137 220 128 98 238 68 57 180 192 197 236 99 177 10 70 106 14 210 229 145 130 131 119 164 75 135 239 180 18 199 118 23 15 159 102 243 116 153 51 22 242 76 42 2 100 170 135 0 137 18 224 130 114 154 123 114 61 218 239 29 106 189 241 10 35 213 94 173 76 39 214 142 100 147 63 135 57 147 31 72 134 29 92 92 85 182 44 123 125 124 146 95 186 43 136 226 52 9 185 20 201 179 139 212 47 190 85 151 82 180 160 142 194 170 243 116 184 31 236 218 66 3 48 224 237 131 47 228 87 153 89 246 107 251 254 60 254 188 190 49 85 5 140 52 228 167 9 243 137 17 15 232 116 207 38 45 191 254 248 53 225 127 251 164 29 112 12 79 54 246 247 33 205)
#f
())
#(164
"oid with invalid node"
#vu8(49 50 51 52 48 48)
#vu8(168 0 140 240 134 130 165 189 167 13 245 241 203 5 23 139 230 241 240 115 9 92 217 46 96 159 139 171 240 196 89 56 162 203 143 2 87 85 177 115 175 1 129 232 126 231 159 138 115 230 1 51 244 24 62 225 114 220 96 214 234 15 109 48 171 96 188 129 107 210 57 176 188 112 205 47 149 226 214 210 128 188 116 1 210 124 197 54 218 194 60 235 237 179 130 2 167 244 161 112 151 40 179 211 45 203 103 178 228 8 17 83 198 82 236 15 83 193 60 133 109 223 192 197 112 136 196 166 172 170 79 239 24 170 234 26 187 144 47 139 202 113 71 197 75 177 61 67 15 121 44 72 228 211 5 10 112 89 34 215 59 42 25 243 7 72 87 132 19 56 82 31 185 150 129 6 2 104 58 176 200 41 155 186 185 197 152 117 74 52 148 122 41 131 221 99 199 108 247 75 6 248 28 2 167 141 68 141 34 142 202 32 90 136 202 192 135 119 35 131 90 251 70 134 156 243 138 40 180 105 98 38 159 143 171 86 149 66 58 195 179 127 136 213 221 149 18 124 40 10 26 64 24 228 119 85 185 191 92 84 186 124 71 12 30 245 206 120 220 73 217 161 117 160 115 82 237 178 111 163 107 101 197 49 99 194 97 205 255 53 233 226 149 92 94 58 121 58 0 161 76 247 201 12 180 196 58 32 9 216 227 200 150 16 30 82 38 230 95 9 104 4 242 111 100 74 225 49 31 66 71 169 114 166 13 198 178 32 98 237 181 101 84 12 228 243 244 204 207 235 87 234 42 44 201 32 90 89 46 127 82 42 136 103 252 229 104 31 41 44 95 32 53 133 159 180 7 144 87 43 49 158 116 143 174 27 124 216 252 248 116 33 224 221 248 162 11 58 233 192 34 68 198 82 62 235 53 15 112 161 149 66 88 126 170 158 151 152 241 4 19 108 138 182 115 199 243 188 241 153 83 45 20 241 122 181 50 249 87 205 106 252 91 94 87 241 80 100 216 179 158 244 68 255 81 61 125 224 44 202 227 130 177 74 235 44 172 0 40 229 253 184 193 252 51 97 90 228 217 53 52 243 4 76 151 18 104 22 161 115 45 129 76 237 107 208 67 4 91 145 138 79 91 151 200 230 82 177 97 48 242 5)
#f
())
#(165
"long form encoding of length of null"
#vu8(49 50 51 52 48 48)
#vu8(71 231 102 75 29 253 110 71 17 244 222 144 253 49 28 29 184 118 89 234 153 35 130 213 225 138 169 254 90 36 41 238 201 203 122 188 6 62 63 227 55 30 23 94 201 165 31 228 166 41 216 81 53 92 56 7 39 67 195 115 82 103 79 106 17 61 189 121 40 105 148 197 198 173 55 246 33 40 52 67 227 12 174 9 79 131 69 133 231 171 37 128 246 212 216 160 147 16 235 86 190 145 5 224 244 76 231 234 156 240 218 119 102 194 185 190 219 247 50 17 58 77 177 188 11 199 242 86 156 183 16 147 235 80 192 203 136 102 138 120 192 64 134 12 181 78 25 163 206 175 215 220 168 134 12 73 32 219 99 118 220 55 20 158 91 24 212 52 133 61 54 235 89 119 228 1 44 116 79 170 115 152 50 213 241 30 51 21 29 165 68 3 116 102 120 69 110 62 112 167 172 43 56 2 199 25 176 137 34 7 242 186 186 202 122 60 118 63 227 57 159 225 9 132 98 115 224 16 187 105 209 94 9 215 217 25 59 46 240 15 240 223 182 92 152 58 44 136 190 207 35 47 197 189 36 111 68 30 157 198 26 35 208 228 194 92 251 181 39 235 214 78 197 3 172 123 77 80 28 211 151 227 114 189 177 4 170 32 4 178 85 164 225 20 36 170 201 120 195 44 158 43 97 151 139 27 40 24 202 242 121 85 66 174 26 120 8 244 127 248 175 22 228 88 240 119 27 222 163 112 211 27 28 250 224 240 215 62 20 217 157 211 135 44 77 155 237 179 202 246 48 221 198 255 73 217 141 243 96 201 198 196 166 30 12 148 213 175 62 82 57 172 68 58 168 239 28 174 203 29 34 177 72 135 70 105 194 99 195 37 230 183 0 138 64 78 83 116 169 220 16 33 77 65 45 93 0 218 129 74 111 154 240 200 60 64 121 78 63 234 115 49 243 211 229 115 107 23 108 141 110 225 58 40 239 226 82 57 173 221 76 228 212 204 191 157 121 237 224 242 205 83 245 117 164 196 122 70 193 73 36 23 143 45 74 252 45 147 208 114 45 133 203 125 62 96 157 76 242 112 149 14 83 0 193 167 93 210 252 16 190 100 33 160 192 22 219 61 45 104 99 246 68 251 104 165 221 241 53 76 96 117)
#f
())
#(166
"length of null contains leading 0"
#vu8(49 50 51 52 48 48)
#vu8(76 243 107 241 114 56 245 251 84 202 44 96 171 241 246 109 184 157 103 75 163 89 138 25 174 22 181 156 105 184 24 189 235 205 28 7 132 142 184 217 191 26 199 109 64 199 248 39 114 137 248 57 154 221 36 98 153 63 65 254 107 94 12 201 61 130 182 145 227 140 47 247 220 126 10 42 210 103 108 108 225 91 105 227 34 167 108 176 93 220 106 108 213 71 178 209 38 84 157 110 122 98 179 125 201 18 27 104 181 42 21 108 1 52 200 103 157 85 56 3 173 38 104 85 29 98 189 163 209 111 211 161 36 137 199 224 237 200 127 164 218 137 101 98 126 85 37 109 68 30 0 83 53 204 33 42 123 219 66 230 44 125 35 19 147 68 4 27 142 176 17 59 208 245 198 64 39 255 108 92 11 208 138 4 42 40 123 42 197 212 90 0 42 146 166 154 126 131 37 165 69 99 52 33 159 121 193 116 185 89 175 231 140 121 77 241 168 174 255 24 14 148 236 61 44 29 37 184 173 93 28 8 60 55 43 44 243 206 181 105 165 118 133 24 135 125 33 16 81 103 235 137 207 55 147 54 47 220 89 16 102 226 111 187 176 40 230 242 29 163 74 58 177 63 38 216 195 208 163 232 189 206 5 163 1 146 72 55 152 156 254 245 22 255 76 24 207 94 116 176 206 181 156 55 95 88 91 197 185 249 155 177 192 41 104 190 187 24 247 225 111 99 44 51 199 159 52 25 116 240 248 249 214 36 61 89 147 46 33 178 120 118 8 131 248 151 36 233 150 213 237 125 23 154 250 150 124 235 55 208 164 164 171 221 105 74 56 107 108 54 247 33 77 211 57 253 135 226 119 26 54 81 127 208 73 192 64 144 130 125 182 160 117 145 120 70 75 208 19 37 143 204 79 35 51 94 193 57 140 40 86 151 178 244 16 119 124 138 154 162 199 200 153 95 250 22 191 113 218 96 254 86 224 120 42 31 198 165 133 34 225 188 0 14 94 152 57 229 184 18 255 34 15 200 132 254 53 255 39 105 180 222 190 81 110 173 85 46 252 79 149 106 94 249 250 49 208 241 53 35 214 196 129 141 100 212 177 87 198 162 240 68 220 104 200 83 113 160 242 61 222 53 63 160 134 222 128 76 241 248 249 22)
#f
())
#(167
"wrong length of null"
#vu8(49 50 51 52 48 48)
#vu8(90 201 74 154 127 173 86 16 18 226 28 105 171 238 253 46 49 231 156 41 120 242 81 46 184 163 213 156 80 67 12 11 163 186 71 235 240 1 183 205 15 107 56 69 82 85 195 191 36 27 238 177 180 255 228 124 138 50 145 159 249 231 174 250 176 35 82 212 169 95 37 8 211 84 9 219 240 136 63 43 157 107 168 150 60 19 216 164 3 9 108 172 107 230 166 30 82 198 166 46 65 107 152 3 97 4 244 55 86 102 169 86 110 120 211 190 83 112 138 65 240 64 125 73 18 167 218 3 194 141 14 223 105 230 218 193 101 63 142 223 5 208 129 166 55 227 225 121 211 13 89 95 53 247 231 95 244 24 232 73 145 222 175 236 134 62 16 14 117 141 232 85 206 81 193 208 71 253 44 82 36 46 164 243 107 13 90 118 144 183 132 188 201 158 176 158 179 160 212 52 225 42 237 200 41 205 155 67 250 109 77 45 214 86 110 18 41 91 37 201 162 4 176 197 10 101 243 170 105 202 32 248 241 242 3 96 103 137 26 73 39 191 63 224 11 168 146 236 144 74 110 100 208 30 218 140 34 71 101 253 60 225 65 3 207 77 75 98 97 228 220 77 13 211 171 17 39 7 242 186 17 59 175 105 165 99 36 55 6 137 48 42 149 111 157 27 16 66 169 226 186 174 141 122 227 133 130 245 151 171 134 191 236 8 249 158 137 112 223 33 135 114 189 162 7 106 226 79 34 101 250 26 45 25 125 120 20 60 61 172 237 117 230 102 4 9 141 5 135 37 142 237 97 80 156 206 132 84 16 161 138 129 255 68 254 139 70 222 131 144 158 176 255 24 247 201 154 187 30 55 99 188 9 222 84 208 117 0 98 107 213 241 31 33 240 202 98 209 184 205 166 41 125 123 168 51 147 76 90 148 198 15 106 60 184 134 138 143 124 173 208 26 21 79 2 141 66 192 0 151 22 18 83 242 35 177 77 123 54 86 64 87 40 128 69 25 253 107 144 54 88 235 10 86 173 165 192 131 72 194 38 61 48 179 180 118 189 190 229 129 15 13 252 19 21 39 165 102 154 65 148 207 239 17 192 69 51 108 77 96 169 150 110 145 23 177 181 192 51 31 158 185 177 102 151 82 176 178 89 191 41 114)
#f
())
#(168
"uint32 overflow in length of null"
#vu8(49 50 51 52 48 48)
#vu8(136 8 116 12 91 57 16 16 215 141 157 175 24 179 16 143 76 148 160 239 237 217 41 79 115 201 119 162 93 111 179 114 83 93 92 183 164 167 36 85 241 197 64 9 127 135 99 220 147 116 131 7 195 205 117 133 42 87 45 7 3 12 23 39 218 252 112 103 68 112 231 174 241 45 240 159 238 46 181 59 161 245 38 222 142 21 89 144 16 165 190 191 24 215 113 26 130 64 11 117 113 134 229 89 114 255 196 246 73 60 26 152 77 240 204 233 170 83 65 157 76 174 161 196 244 148 112 129 239 62 201 231 136 139 91 64 228 238 148 59 43 32 71 236 231 183 198 59 224 134 96 64 141 140 176 97 255 253 107 67 179 109 1 208 97 114 50 195 166 119 12 226 166 186 30 94 10 186 134 199 122 243 230 12 116 103 126 167 228 88 113 154 170 192 178 107 197 124 62 17 93 179 48 96 63 47 245 170 82 59 214 83 11 106 252 50 224 20 182 154 74 146 156 216 51 132 170 186 111 246 34 13 67 191 189 229 202 184 47 87 43 141 143 217 225 165 123 142 193 132 244 143 161 116 151 74 228 61 94 125 16 52 48 30 31 101 101 84 146 152 145 214 25 41 180 63 119 2 60 56 155 214 81 220 245 242 39 139 217 201 158 247 239 97 164 108 26 30 165 137 190 237 54 232 14 252 130 30 136 101 65 42 156 34 174 254 20 148 10 177 126 104 5 93 121 243 40 235 94 191 249 212 59 171 78 130 156 81 233 221 220 94 137 0 193 184 35 129 201 229 163 252 86 249 34 169 94 59 86 197 210 233 207 39 151 189 57 76 15 182 42 71 165 197 79 25 199 100 40 236 240 189 46 94 59 132 90 26 20 241 70 96 147 42 68 108 150 23 241 183 65 138 100 34 18 189 52 101 205 129 37 146 192 203 205 165 200 140 136 32 197 20 240 112 42 32 197 147 128 174 120 33 144 240 226 228 245 246 219 189 41 103 41 215 248 31 243 101 247 216 242 115 244 157 39 224 225 34 73 48 180 143 134 8 90 112 42 69 202 219 26 239 188 7 235 13 251 86 194 98 131 19 149 59 239 179 152 139 32 249 189 251 198 72 31 24 22 160 83 68 197 167 118 206 32 64 72 151 87 29 249 52)
#f
())
#(169
"uint64 overflow in length of null"
#vu8(49 50 51 52 48 48)
#vu8(98 179 103 253 152 118 103 134 150 9 73 172 210 219 30 8 72 48 236 173 141 213 35 112 80 14 84 53 122 213 205 31 37 2 116 253 49 8 84 11 181 65 1 152 30 50 105 73 181 166 113 245 130 172 61 5 164 170 149 155 224 71 84 241 252 194 15 63 196 58 201 16 69 90 33 117 121 203 5 245 10 187 201 9 31 168 205 118 253 124 218 3 12 137 156 173 46 183 205 118 234 58 55 73 213 36 207 8 173 72 152 56 46 72 250 249 211 65 19 98 130 128 179 6 224 24 10 31 155 129 34 191 138 105 187 83 237 25 32 12 69 254 245 44 138 65 219 57 8 57 105 108 77 230 93 40 127 11 144 175 185 45 131 11 123 150 168 79 18 44 112 223 147 219 67 165 40 118 170 88 209 108 26 218 40 255 250 212 41 149 7 91 65 240 17 125 102 31 20 95 17 184 187 24 152 39 8 239 119 158 39 208 210 48 57 48 117 43 173 210 183 63 87 32 129 44 86 38 179 138 28 249 182 167 89 196 116 216 37 107 102 141 80 5 14 0 249 159 253 170 17 28 179 244 217 111 143 104 144 172 144 141 252 86 172 208 7 106 106 234 19 222 144 74 205 202 225 125 204 141 58 171 252 144 248 247 165 30 159 67 14 86 202 143 176 238 59 222 200 45 39 9 245 20 237 3 114 85 236 127 175 194 46 122 57 96 20 255 124 71 158 147 51 69 90 177 112 126 11 101 135 12 203 253 10 63 23 184 163 60 47 163 224 109 157 43 71 167 124 62 162 93 252 149 81 159 47 40 229 78 215 48 129 87 150 92 170 38 202 255 1 246 77 178 130 167 172 15 81 253 235 61 105 19 147 159 28 134 134 244 67 74 47 74 171 176 105 42 194 176 158 38 157 116 168 61 139 92 145 125 18 117 72 29 218 83 169 176 64 245 51 183 48 126 46 186 109 111 229 130 245 165 148 148 81 130 223 91 26 125 133 95 54 189 79 169 164 123 224 145 44 27 229 174 163 108 163 70 198 240 146 21 113 17 200 159 232 37 255 189 123 201 217 165 189 119 139 140 37 124 144 198 103 124 175 114 193 118 239 226 100 95 65 58 207 86 22 255 252 157 201 255 243 77 77 49 42 6 71 204 194 150)
#f
())
#(170
"length of null = 2**31 - 1"
#vu8(49 50 51 52 48 48)
#vu8(173 132 242 96 23 95 154 1 83 66 7 34 226 215 108 109 224 210 187 56 237 204 245 16 4 31 53 129 138 24 2 182 121 184 177 186 54 136 234 72 109 161 197 138 10 34 23 124 80 13 146 229 235 136 14 110 160 237 181 67 195 15 17 115 62 85 22 126 249 11 179 217 30 10 226 124 162 97 127 61 223 92 242 37 115 53 69 138 214 89 89 235 101 82 223 68 61 225 221 49 40 71 91 165 219 19 5 36 9 48 7 181 212 183 198 255 133 24 97 7 21 37 35 179 122 161 152 30 79 201 149 193 4 90 1 142 53 89 190 82 171 88 14 171 115 66 79 13 52 70 18 190 41 25 123 75 213 113 252 52 40 124 152 127 9 12 99 144 153 219 105 63 155 133 54 139 97 182 165 6 162 131 17 109 243 207 101 24 128 149 157 12 152 207 14 3 114 244 70 127 48 181 126 239 104 62 189 5 125 109 200 169 179 99 188 149 137 193 14 220 233 197 34 242 246 223 116 8 233 69 62 185 67 144 80 201 160 30 235 149 249 165 74 100 193 43 200 203 200 131 242 58 72 133 200 27 13 47 208 20 89 202 181 64 96 114 26 199 36 90 177 180 205 198 180 193 201 187 68 20 163 212 169 45 39 59 94 220 233 249 71 185 197 194 56 193 15 195 131 70 30 62 175 17 218 134 119 230 82 54 231 15 241 141 179 150 106 160 124 245 150 129 78 173 13 202 82 48 129 180 119 152 223 204 7 65 87 32 112 90 136 139 33 214 35 22 198 117 168 163 171 249 125 238 231 100 30 247 65 141 167 21 255 221 0 222 84 112 109 225 187 69 135 99 20 46 202 40 170 209 255 169 40 160 107 91 252 178 138 22 41 241 166 6 205 182 217 175 140 15 147 66 94 87 204 29 214 176 11 11 251 237 184 242 187 247 244 98 207 103 125 212 72 62 49 120 85 138 13 110 243 203 74 213 95 90 48 43 141 59 77 131 235 237 74 204 236 29 238 138 151 195 8 248 97 151 196 169 162 20 149 49 115 154 192 13 58 131 44 199 249 206 173 46 140 63 199 200 86 48 64 80 57 35 9 10 250 213 179 114 102 194 151 69 43 82 114 17 82 98 48 188 162 147 188 175 218 68 35 152 55 153)
#f
())
#(171
"length of null = 2**32 - 1"
#vu8(49 50 51 52 48 48)
#vu8(36 225 250 223 13 167 145 175 99 36 33 112 161 237 135 194 221 140 159 102 220 124 85 132 185 83 250 39 205 172 179 226 235 1 117 8 107 52 180 2 187 247 218 150 249 229 207 103 38 160 109 100 114 184 24 112 27 150 53 48 185 253 200 83 140 194 41 240 192 93 136 54 100 222 109 197 142 14 248 34 201 132 188 131 219 98 102 246 47 110 246 182 97 227 96 161 254 172 232 74 195 7 12 169 14 228 36 225 154 251 187 97 35 228 234 16 148 7 143 175 205 173 214 160 231 197 179 161 10 195 143 166 69 105 39 2 30 94 32 29 93 187 50 119 158 150 34 82 149 11 211 38 47 89 81 191 106 45 9 46 97 227 97 15 217 248 248 136 160 145 254 149 208 226 154 107 81 158 177 128 137 6 69 135 128 175 197 30 71 109 201 201 77 77 21 56 90 0 72 48 75 238 231 90 199 57 214 152 171 210 55 47 89 177 7 191 49 201 175 45 106 52 118 8 28 122 154 43 31 170 27 123 65 64 144 249 113 73 18 5 216 135 222 227 14 213 110 92 244 59 245 186 22 13 111 73 9 216 204 53 1 85 51 222 45 199 148 143 81 148 126 38 142 162 150 148 252 68 188 32 88 42 195 17 132 151 94 240 67 52 91 50 150 199 119 105 153 210 182 90 94 212 41 130 111 101 140 121 219 93 160 77 81 27 1 194 221 226 60 208 175 23 251 185 90 153 191 208 206 188 148 89 138 223 192 198 170 88 243 198 242 74 37 53 132 158 9 77 142 135 168 96 226 50 172 189 75 190 192 96 218 204 175 163 250 31 168 183 221 104 250 3 116 174 79 235 113 247 175 217 233 145 17 131 219 68 158 198 124 137 32 45 156 163 235 99 25 40 107 115 119 115 58 190 12 139 33 90 203 100 3 82 38 117 48 171 48 127 148 240 167 15 200 100 49 231 241 146 14 151 162 246 126 198 99 65 131 80 168 32 237 91 194 223 109 252 176 86 1 210 65 40 114 14 173 197 6 140 207 231 209 223 3 145 207 4 39 197 85 91 97 31 76 154 95 55 72 229 37 187 125 29 226 189 250 55 184 120 121 23 252 111 114 135 126 43 158 151 0 104 152 45 179 172 205 222 217 181 51 64 42 10)
#f
())
#(172
"length of null = 2**40 - 1"
#vu8(49 50 51 52 48 48)
#vu8(78 41 213 20 186 185 205 200 130 31 104 143 215 200 70 218 171 21 70 97 176 252 100 4 180 90 14 43 72 123 110 168 166 110 182 187 120 34 225 14 62 228 206 96 18 7 230 66 55 178 159 30 112 128 250 5 156 76 170 117 49 173 165 156 215 216 217 53 95 56 39 55 172 70 41 39 49 56 145 35 146 18 13 93 166 171 97 126 129 12 206 50 198 124 12 212 89 239 42 149 248 161 83 22 122 40 95 33 182 122 49 42 1 193 80 202 148 205 156 182 194 4 177 249 138 69 112 94 164 133 102 188 235 69 167 32 15 22 45 48 171 255 243 60 151 183 236 223 58 190 198 100 7 214 156 13 155 200 150 74 168 213 204 24 59 14 224 135 59 211 189 98 208 210 152 56 177 174 81 101 93 47 10 242 255 129 135 48 245 178 109 186 21 112 213 105 210 113 200 116 57 94 139 252 236 195 64 53 192 162 22 136 31 124 95 246 187 247 21 57 124 45 100 17 146 82 89 131 87 250 157 190 47 203 211 191 118 211 74 53 185 171 183 206 66 227 54 176 15 124 209 224 54 159 41 109 4 37 250 64 16 33 32 247 102 132 222 245 196 210 203 31 130 169 203 179 94 11 12 98 144 28 103 105 89 174 184 164 105 192 124 33 207 103 44 152 120 239 238 222 161 47 228 138 16 169 56 37 55 48 210 170 93 247 39 126 64 27 203 161 216 58 109 160 159 6 118 157 157 21 212 199 68 236 57 234 1 19 90 100 91 137 65 145 151 175 73 208 199 199 31 141 64 245 120 40 45 129 246 243 0 26 142 230 195 185 53 59 69 139 43 61 180 230 106 41 105 148 13 58 36 4 180 196 205 238 186 21 100 140 185 137 137 249 238 211 77 253 173 250 161 7 185 208 137 211 129 83 9 159 187 132 71 167 130 94 244 21 17 175 113 14 239 108 34 123 28 224 52 193 10 98 148 95 64 236 211 136 203 172 245 71 251 68 184 213 51 172 251 189 191 19 224 120 151 154 162 24 154 165 51 222 203 134 242 59 127 218 230 124 72 7 89 23 179 36 87 180 246 123 168 75 0 230 87 190 163 3 226 61 206 96 31 116 160 172 167 143 108 94 240 57 215 102 103 135 112 17 31 249 14 200)
#f
())
#(173
"length of null = 2**64 - 1"
#vu8(49 50 51 52 48 48)
#vu8(158 97 167 121 178 161 46 18 143 135 203 195 9 124 76 79 118 252 13 2 118 207 30 122 28 180 236 237 159 204 15 212 245 69 226 71 198 205 107 223 185 56 53 88 47 21 49 97 64 62 250 192 255 43 96 68 32 133 92 102 134 145 176 103 161 46 16 136 250 161 176 87 11 107 51 130 27 69 75 64 92 204 207 166 10 157 36 11 237 163 234 41 92 117 15 69 168 14 49 107 76 65 106 144 21 148 183 64 109 236 181 140 230 170 65 42 144 64 128 127 205 80 161 0 183 252 216 130 36 109 29 105 36 229 135 166 166 37 160 253 103 137 222 241 10 119 55 159 251 101 60 150 236 160 235 187 114 165 179 0 197 71 126 165 52 230 248 83 241 162 134 95 87 19 162 55 152 53 179 72 239 14 110 121 194 56 18 214 35 18 20 35 124 155 25 220 249 46 216 180 116 189 93 218 69 10 186 63 153 136 84 241 35 113 13 40 40 120 104 27 146 19 75 133 20 88 176 113 233 40 99 240 48 93 149 155 205 118 137 229 151 208 62 244 142 202 220 238 183 79 125 219 85 70 184 226 26 157 62 73 80 93 22 82 11 246 122 216 160 43 30 214 96 230 253 146 136 218 69 78 67 212 212 93 50 173 47 79 8 124 36 168 153 191 116 240 22 58 244 247 208 88 209 78 115 58 32 120 0 27 214 25 135 94 13 96 54 20 169 91 118 212 101 11 51 143 108 210 68 177 254 44 247 2 48 244 83 248 77 177 171 234 187 30 143 112 207 38 80 187 55 98 227 17 154 21 111 187 140 92 29 173 186 111 207 148 189 96 113 146 191 171 45 206 161 90 97 132 231 27 49 208 56 186 249 57 152 231 33 53 175 30 226 44 87 1 1 159 74 228 36 75 57 36 42 96 62 152 59 145 158 250 97 194 33 171 133 37 77 67 35 94 227 55 176 100 19 26 82 221 251 203 41 141 80 7 156 26 158 132 112 12 104 143 20 207 177 198 115 243 71 190 203 109 211 55 195 16 245 123 128 13 18 164 118 194 224 20 239 168 82 69 203 92 88 125 105 195 254 196 245 155 242 189 148 130 35 63 157 122 143 163 41 13 192 117 223 49 51 148 71 212 69 119 162 118 130 17 26 156 65 192)
#f
())
#(174
"incorrect length of null"
#vu8(49 50 51 52 48 48)
#vu8(3 77 176 25 104 207 204 25 214 165 156 154 21 33 79 163 167 245 126 163 154 23 222 113 161 185 46 66 16 180 140 146 153 150 78 195 83 166 166 75 177 133 229 69 170 3 155 121 103 186 182 48 172 71 115 252 228 73 171 26 110 170 174 137 132 37 137 214 201 46 0 71 252 228 231 173 199 17 144 245 84 173 89 44 73 117 205 246 197 176 206 120 179 115 128 64 211 95 160 81 84 121 160 150 116 130 5 46 201 160 191 125 0 173 35 152 235 95 204 7 234 136 104 46 21 141 164 125 243 191 176 216 149 116 155 29 97 49 96 84 43 26 179 4 147 52 74 39 155 209 233 253 66 34 149 26 222 169 119 206 247 234 52 88 225 99 96 240 10 196 75 253 142 111 192 158 63 75 165 146 158 27 251 10 51 144 156 24 3 70 56 84 97 212 182 25 224 205 45 43 124 48 249 76 243 25 47 114 202 57 121 1 160 211 133 117 75 127 128 57 59 205 213 191 176 9 49 174 21 25 77 12 131 168 230 212 163 206 104 44 159 52 226 216 240 223 9 65 174 204 42 162 214 50 230 181 166 5 49 113 254 84 238 132 49 143 48 90 162 224 98 128 254 177 13 188 185 139 0 112 176 219 139 6 32 149 88 182 64 73 96 248 9 213 16 133 3 91 13 3 44 218 103 37 109 116 121 37 104 143 23 249 141 63 48 137 90 67 83 20 199 111 111 105 54 252 111 147 181 61 17 127 160 169 159 163 149 63 253 97 72 153 174 45 218 97 191 105 89 53 197 252 64 138 19 34 255 134 120 193 162 57 216 115 58 201 182 81 115 212 176 74 36 253 195 35 105 1 67 31 161 149 178 173 183 103 153 15 106 158 27 197 21 230 151 27 94 52 171 159 66 107 80 29 247 198 250 209 157 181 84 18 26 125 149 94 127 195 233 195 211 58 190 1 152 178 200 255 135 13 236 194 227 235 49 175 77 67 216 149 20 121 97 39 141 226 158 156 17 166 122 90 191 131 176 206 137 174 236 166 231 8 94 168 174 48 89 94 15 17 224 235 101 208 37 46 12 246 130 200 19 5 75 143 5 253 185 215 124 191 133 32 126 78 235 60 72 185 202 7 223 19 215 113 33 143 189 237 64 43 113 33)
#f
())
#(175
"appending 0's to null"
#vu8(49 50 51 52 48 48)
#vu8(73 133 165 131 178 231 204 101 58 83 67 214 191 250 79 52 158 17 84 65 211 95 89 67 50 183 83 174 0 105 182 110 210 78 101 169 59 190 171 148 178 93 153 44 168 113 182 79 24 151 79 198 94 165 45 206 241 221 149 228 107 43 117 138 132 122 124 102 8 44 171 188 29 8 223 30 59 77 105 221 94 53 26 246 225 220 30 223 45 184 133 30 233 235 242 65 53 173 98 202 68 84 123 203 149 74 229 134 2 247 216 235 53 165 94 136 53 146 103 38 252 49 54 15 232 34 251 18 220 62 8 160 60 166 227 193 146 153 104 47 235 120 93 218 220 232 148 134 238 17 117 118 59 82 234 150 38 126 94 144 204 168 180 151 36 199 124 39 16 42 37 2 241 184 152 53 50 32 160 137 75 238 117 39 133 57 238 197 209 148 49 248 30 217 178 250 61 223 23 149 93 65 186 11 134 207 93 193 231 136 40 168 86 17 135 216 113 64 174 26 141 252 34 100 107 35 223 81 186 117 111 10 246 74 128 107 232 26 101 44 254 206 134 164 126 80 119 245 96 184 158 17 117 142 175 139 1 85 155 224 55 110 160 47 64 203 237 220 151 53 104 27 131 69 15 16 105 111 35 6 208 111 152 191 40 121 179 211 91 5 183 92 223 49 109 98 237 108 220 215 166 68 85 192 100 47 68 177 198 3 211 92 16 66 170 211 82 98 219 41 19 131 64 7 151 171 74 8 117 173 221 160 140 191 244 136 17 201 37 223 116 130 228 104 163 7 107 200 204 137 232 180 183 111 124 146 2 172 213 84 251 234 238 149 190 62 232 213 146 7 255 226 165 70 31 195 1 150 7 236 141 164 194 103 190 41 174 70 70 174 211 134 174 167 43 71 226 171 241 190 94 164 194 202 1 7 174 207 152 19 218 11 166 179 219 66 195 212 136 22 227 92 52 50 160 219 66 244 51 177 33 184 11 70 30 75 147 191 190 38 71 158 172 114 109 94 112 100 58 162 160 203 44 46 77 234 3 165 122 184 232 21 140 106 169 111 160 167 13 5 9 105 228 236 64 186 6 75 217 171 229 157 95 53 203 124 202 85 42 116 93 147 6 240 94 177 161 105 69 213 242 4 119 242 3 242 164 204 105 160 106 82)
#f
())
#(176
"appending null value to null"
#vu8(49 50 51 52 48 48)
#vu8(143 75 68 147 9 251 244 180 96 216 65 89 59 166 107 242 26 17 86 94 148 141 21 92 153 137 65 14 10 17 43 211 140 149 14 36 92 191 48 16 179 66 24 212 140 71 49 129 22 165 246 22 28 90 193 156 155 125 101 198 197 31 255 254 133 46 230 85 211 62 157 197 177 185 43 131 239 204 193 230 131 118 200 226 150 101 168 172 191 86 131 124 63 209 42 222 135 43 36 128 33 231 1 166 74 216 249 158 226 210 99 103 179 70 59 218 35 101 79 215 54 198 77 207 115 127 18 179 114 225 70 239 101 44 29 70 140 219 182 105 174 181 13 219 150 109 166 144 125 44 247 69 109 41 195 226 177 51 65 71 50 124 246 252 210 84 197 54 221 70 7 243 162 168 177 151 213 197 244 69 112 216 142 190 95 232 33 246 86 166 178 84 253 15 160 52 247 165 108 209 229 23 36 182 191 187 245 254 48 18 35 81 44 107 48 160 142 180 248 211 127 16 0 206 202 151 63 244 61 64 154 27 124 55 88 101 36 170 186 73 216 108 245 24 125 254 204 36 216 232 253 194 56 109 193 141 81 157 49 37 247 83 182 114 250 43 175 72 200 248 252 136 63 1 222 1 107 157 38 75 49 134 40 112 52 7 33 200 254 53 226 84 104 155 30 243 190 174 184 185 208 220 214 162 139 234 105 237 232 242 153 114 6 172 48 233 153 158 190 235 21 147 110 36 176 150 74 33 152 249 127 158 251 223 69 55 123 6 76 98 170 166 143 103 214 139 24 24 89 226 249 2 44 178 37 62 235 171 140 57 9 15 200 130 142 214 178 164 74 148 101 212 227 6 143 21 189 65 199 250 113 96 224 207 85 101 24 10 211 5 52 153 98 142 77 145 194 123 191 116 22 66 157 126 39 99 239 48 113 159 230 57 247 46 133 28 48 95 14 164 198 222 126 203 122 1 3 87 193 126 10 58 76 227 174 120 74 120 179 234 189 181 36 19 62 203 89 185 76 58 252 31 255 105 109 125 137 176 57 40 208 255 72 14 211 47 134 16 220 54 217 65 102 90 40 128 196 175 148 253 138 237 103 231 5 66 206 60 174 239 25 187 52 81 126 98 170 86 108 129 241 176 242 50 201 173 207 160 124 130 145 202)
#f
())
#(177
"truncated length of null"
#vu8(49 50 51 52 48 48)
#vu8(26 35 249 8 137 156 253 55 119 141 194 154 73 68 175 234 100 148 178 195 53 100 128 17 51 22 237 118 31 190 194 67 237 66 253 111 14 122 27 213 28 108 67 32 19 203 143 235 140 78 82 3 6 90 139 197 134 109 33 89 134 157 158 75 71 240 184 116 158 96 110 55 31 146 4 220 107 141 19 21 185 227 86 207 77 54 29 161 169 5 74 48 98 14 72 246 104 56 123 29 130 95 83 117 47 222 159 21 252 24 127 100 64 157 241 218 143 168 64 159 9 149 31 68 90 186 170 21 197 243 112 151 92 211 138 0 81 22 135 121 172 119 167 152 169 149 111 198 120 172 214 196 61 243 56 21 88 202 123 59 179 13 61 42 119 191 57 28 197 95 5 126 37 226 32 60 113 155 254 171 125 212 52 167 190 188 132 39 247 11 35 148 151 191 18 103 224 83 144 30 22 30 139 226 212 97 171 0 6 241 81 57 44 89 138 176 140 24 154 181 121 122 52 155 60 6 248 123 130 200 148 247 177 214 48 19 56 225 10 150 3 83 166 48 108 208 243 153 125 230 212 169 243 29 233 207 45 169 81 121 53 206 126 185 25 0 213 23 228 90 102 76 239 228 148 171 140 36 126 14 199 199 111 32 27 106 59 97 156 40 107 216 71 89 181 241 5 93 74 53 61 126 79 235 113 24 91 142 43 0 186 58 6 241 128 16 153 65 1 127 168 73 193 11 217 205 24 124 186 17 84 230 76 74 152 86 245 99 198 175 128 125 111 185 20 251 178 168 67 25 60 35 76 63 147 62 68 47 214 222 78 47 47 186 91 34 141 192 220 83 255 196 19 245 184 236 237 54 217 241 155 137 10 208 170 247 123 142 8 254 244 75 204 83 210 231 178 119 87 134 50 203 48 24 14 100 34 151 210 78 153 117 71 98 54 244 108 208 250 252 217 61 204 180 112 151 254 145 174 209 160 93 254 133 91 98 118 138 178 189 101 87 78 105 116 119 125 84 161 230 98 15 49 227 254 117 122 79 36 228 56 23 174 69 83 138 237 131 194 46 190 144 75 69 59 200 151 150 153 139 60 67 102 29 91 99 134 112 169 212 107 238 208 110 34 8 235 233 137 45 165 189 172 113 39 2 158 26 98 23 49 239)
#f
())
#(178
"changing tag value of null"
#vu8(49 50 51 52 48 48)
#vu8(60 250 45 97 15 136 132 36 106 173 86 22 193 206 76 82 18 178 205 226 13 38 183 251 136 9 233 136 214 255 246 90 195 34 221 68 61 243 47 244 0 141 15 106 159 48 169 144 218 59 76 155 56 48 169 182 249 97 110 27 233 25 77 203 111 5 230 52 188 248 184 241 36 25 145 236 142 146 47 91 61 184 197 248 28 209 180 185 47 82 72 185 174 135 240 1 23 55 92 155 176 47 244 54 238 109 7 140 159 134 241 213 99 91 17 0 197 196 29 170 67 201 120 27 65 79 162 160 101 185 6 99 2 89 151 104 145 225 186 75 151 132 143 16 195 66 91 189 220 30 148 215 243 232 143 140 94 53 133 28 219 31 7 15 202 99 160 228 145 20 175 237 224 124 176 47 38 136 194 51 126 99 40 73 206 248 181 38 111 30 30 117 47 79 3 139 177 92 124 8 222 59 191 254 134 113 40 12 80 227 137 226 173 168 220 51 239 119 127 59 75 198 37 148 6 28 174 18 194 26 9 151 225 190 128 125 201 167 141 231 168 179 157 53 69 138 56 91 234 161 12 206 116 60 197 203 225 5 234 43 47 54 253 166 159 115 20 237 252 241 76 144 107 168 159 199 189 17 138 63 162 200 116 207 114 253 80 189 187 85 25 233 250 5 75 36 168 97 23 177 182 207 242 103 77 98 215 68 220 239 170 221 230 32 151 15 98 106 105 217 209 219 21 17 52 243 218 225 74 2 135 128 1 224 228 167 239 243 40 37 94 158 6 205 28 241 129 127 172 12 249 231 100 65 119 163 180 111 65 125 152 69 6 10 140 98 226 0 45 188 103 2 175 31 62 183 136 34 237 216 127 220 158 208 30 235 141 111 163 187 212 52 206 91 8 157 195 146 44 15 10 125 86 255 207 135 68 33 255 204 132 60 38 117 248 130 222 28 231 7 185 121 126 115 228 20 74 30 197 50 75 107 54 124 43 28 42 183 163 235 236 113 206 136 130 81 146 225 149 159 193 212 228 92 124 140 108 193 23 66 12 138 193 81 67 199 164 225 41 185 156 97 192 125 177 240 25 81 195 147 111 83 7 86 109 246 58 232 18 8 171 59 205 122 106 103 153 13 54 191 209 139 74 244 28 100 216 238 54 80 13 34)
#f
())
#(179
"changing tag value of null"
#vu8(49 50 51 52 48 48)
#vu8(168 93 228 167 121 180 208 163 57 149 158 186 15 149 23 244 8 237 135 132 114 5 78 33 93 6 103 96 114 42 165 79 24 151 126 138 88 199 181 253 54 165 240 98 32 215 91 46 107 214 228 106 71 30 107 88 223 130 32 91 37 69 140 19 167 163 111 119 137 189 82 233 96 36 68 3 241 164 149 223 180 254 180 78 11 13 116 91 153 8 222 58 120 50 245 148 19 53 165 155 249 244 206 50 213 184 250 184 141 182 74 111 187 4 63 8 75 250 229 179 211 136 211 140 62 34 200 147 73 29 184 215 153 90 146 6 252 137 174 41 128 96 147 225 192 5 106 128 83 77 32 244 26 201 148 115 235 60 80 105 90 181 201 141 238 174 120 69 138 0 54 110 98 14 251 137 11 222 151 50 1 208 189 45 197 232 194 58 90 77 73 249 77 9 232 150 103 240 41 198 140 122 100 244 104 49 167 24 218 95 22 14 223 156 133 231 233 144 198 85 122 61 198 253 63 31 78 224 91 109 19 90 187 28 27 51 142 16 16 97 217 25 126 214 242 145 144 12 222 98 126 59 243 71 87 230 93 103 15 56 52 194 233 145 194 124 238 81 93 54 243 6 54 159 50 177 19 101 83 36 82 66 216 206 77 218 6 214 204 31 111 89 191 120 76 246 170 229 13 35 69 186 184 4 169 52 186 201 211 189 161 76 232 240 230 88 70 78 66 240 250 222 45 107 70 79 206 136 73 111 122 135 106 165 25 243 52 242 8 77 131 50 58 67 16 202 45 182 186 121 237 36 239 232 225 52 153 99 211 252 125 251 181 106 223 7 82 66 125 192 87 232 143 178 80 120 9 98 223 67 154 111 186 44 227 94 187 74 102 104 39 133 85 80 13 50 117 150 151 186 56 59 43 106 199 11 147 7 217 73 112 101 164 249 64 25 107 56 74 55 31 201 1 149 222 55 8 12 113 41 245 132 229 124 137 59 29 69 234 26 155 135 177 194 45 200 227 186 121 226 169 23 101 206 160 148 147 47 182 84 76 3 101 150 14 200 122 233 209 206 66 199 97 44 62 102 190 133 149 229 196 142 201 108 44 189 61 178 159 11 167 112 131 106 30 224 16 105 250 222 147 98 91 66 34 221 34 244 105 13 33 225)
#f
())
#(180
"changing tag value of null"
#vu8(49 50 51 52 48 48)
#vu8(144 207 152 253 173 3 66 169 96 101 228 147 130 60 202 222 155 100 186 125 85 133 78 165 77 84 39 181 152 33 147 114 126 18 56 46 86 38 225 194 18 149 81 211 137 182 19 196 204 247 210 158 247 193 183 175 137 91 16 129 118 14 171 52 211 84 24 12 34 230 74 108 78 158 93 170 0 161 58 125 128 70 71 133 3 211 18 26 2 201 255 227 92 59 210 184 129 129 95 56 132 151 214 110 163 152 91 172 78 185 47 120 59 83 180 232 249 181 30 84 199 161 21 170 52 18 104 142 59 138 82 97 210 0 53 148 91 145 206 224 24 57 205 184 171 229 29 150 168 80 191 80 100 102 189 202 8 125 186 253 161 215 239 242 145 112 196 201 119 177 139 242 24 210 146 18 226 223 193 112 145 140 238 108 223 182 252 227 41 145 183 26 17 3 231 223 134 238 49 144 5 9 229 25 229 158 203 204 116 201 152 0 162 65 219 159 233 247 144 12 196 143 84 163 178 147 102 105 107 101 241 90 5 123 43 82 153 206 146 185 117 192 192 67 138 43 120 93 147 59 19 31 110 210 174 133 6 203 250 252 0 87 175 177 66 133 125 144 38 76 7 222 221 151 7 168 102 186 21 10 28 84 250 118 250 60 164 102 39 186 67 140 242 97 153 30 30 250 115 32 79 143 108 167 174 30 240 65 221 82 136 134 103 188 227 54 100 27 149 81 97 199 199 24 117 108 74 76 238 127 171 108 185 213 185 138 150 229 65 121 2 179 15 81 131 40 230 248 196 5 97 94 94 245 59 30 230 133 8 28 61 71 88 218 120 114 57 95 167 183 1 7 39 184 115 211 143 45 145 100 242 84 238 131 130 38 31 140 164 231 34 18 97 8 44 233 217 19 54 41 51 162 229 241 179 255 23 54 20 119 130 176 161 142 23 233 19 53 63 16 217 168 203 246 67 167 55 67 163 123 8 91 96 143 45 149 121 190 122 152 92 29 238 88 23 44 91 80 188 67 21 251 44 195 43 214 47 152 118 174 72 38 173 117 84 133 115 212 183 206 28 10 175 129 107 145 169 183 30 78 126 19 78 64 66 178 25 182 234 24 88 20 181 162 101 56 63 112 185 49 30 227 57 101 241 96 32 210 89 211 74 186)
#f
())
#(181
"changing tag value of null"
#vu8(49 50 51 52 48 48)
#vu8(38 188 81 165 202 145 108 6 149 76 83 247 140 249 203 152 40 190 191 252 240 168 166 101 227 245 123 33 177 213 68 141 68 210 1 60 212 77 242 134 8 1 37 196 153 99 149 56 77 233 42 50 227 1 54 159 34 195 109 85 75 127 175 239 101 170 189 224 101 119 237 206 248 95 67 38 145 6 74 7 253 113 36 75 214 66 151 61 82 103 224 123 109 34 75 26 243 31 15 121 34 195 81 146 243 1 30 50 253 100 207 87 249 238 233 175 80 97 54 181 13 10 137 87 233 167 1 177 160 174 46 49 21 198 169 95 244 55 254 23 219 25 95 133 219 140 234 133 10 110 234 233 156 250 244 150 172 28 224 35 185 9 18 126 194 243 215 152 23 52 135 144 251 136 211 109 87 119 56 78 12 47 243 111 86 22 166 248 5 183 64 120 229 1 161 232 214 27 41 251 146 233 95 20 98 79 249 251 86 222 58 36 210 143 190 16 161 17 88 159 243 59 40 69 89 128 65 11 54 198 54 191 21 159 148 239 48 185 241 140 163 230 237 105 160 213 147 224 106 121 187 26 11 6 109 113 128 100 149 110 168 132 199 254 19 247 188 128 249 150 14 254 227 156 205 212 93 54 104 107 231 76 67 202 65 6 233 77 193 190 36 215 153 97 14 251 210 251 80 2 226 84 145 131 54 44 160 239 244 155 217 151 24 85 194 159 196 172 49 167 89 165 123 45 232 219 11 30 34 109 146 75 74 160 224 79 3 90 60 247 192 204 221 17 142 87 122 14 235 174 77 152 79 2 48 40 124 102 109 152 157 74 206 65 224 45 168 199 4 195 181 162 170 149 223 161 209 143 71 220 21 50 169 252 206 60 236 106 73 202 22 228 114 136 133 125 117 83 211 82 105 22 169 118 240 234 162 56 169 227 162 211 119 20 221 172 206 11 64 226 96 245 110 28 205 144 115 70 98 48 183 211 40 250 105 202 175 121 3 10 132 161 170 202 116 28 193 150 238 42 201 164 77 154 212 120 136 86 233 251 81 12 52 185 204 214 26 171 137 167 37 135 1 113 184 168 235 188 163 94 160 150 142 251 68 19 70 194 240 78 79 255 193 148 40 229 78 249 107 60 249 101 147 197 121 163 51 54 230 204 28 210)
#f
())
#(182
"changing tag value of null"
#vu8(49 50 51 52 48 48)
#vu8(172 12 43 238 209 152 77 244 188 87 182 172 115 143 18 114 63 139 219 162 141 124 154 107 68 148 205 38 202 17 139 245 4 144 211 102 161 2 148 67 189 119 84 204 80 126 167 133 174 85 231 38 118 43 17 191 90 214 135 52 47 100 177 228 142 226 237 82 165 63 29 255 77 90 147 156 88 95 45 221 28 228 203 21 196 96 245 180 138 201 251 142 230 240 248 227 8 35 115 25 207 116 69 198 212 196 254 126 236 213 237 177 39 234 224 20 150 180 112 170 171 138 6 72 142 155 182 71 51 102 171 33 68 136 85 35 127 31 98 42 60 65 144 147 35 108 178 182 253 182 114 237 232 9 242 58 251 103 95 21 231 114 63 172 190 125 84 41 80 133 110 75 16 65 9 214 230 71 216 14 41 135 108 105 143 128 219 169 252 203 39 156 43 207 187 40 146 82 231 132 119 183 118 191 48 185 140 36 5 185 251 170 94 245 61 93 132 110 223 112 33 90 153 237 107 250 87 138 97 58 156 208 205 197 130 114 105 49 30 253 200 203 158 144 127 252 240 230 97 97 250 178 196 235 78 58 174 115 162 26 21 155 52 26 56 217 39 85 163 9 72 84 88 139 30 94 138 66 127 211 16 242 74 13 84 34 253 137 103 211 111 160 197 78 253 244 113 221 35 12 194 208 187 131 121 137 252 25 125 25 55 134 252 132 21 134 73 201 20 230 147 34 193 216 49 239 16 251 216 210 106 108 245 167 142 134 182 255 89 88 180 146 32 26 189 211 195 192 15 53 8 238 209 108 45 36 61 21 180 164 27 236 242 105 43 69 173 53 27 56 133 80 192 69 32 54 19 73 223 81 128 1 229 176 165 223 49 175 214 62 103 68 12 224 45 114 136 13 240 155 106 53 86 32 15 104 222 224 235 102 94 40 125 25 121 117 201 152 241 50 114 205 2 224 166 180 27 109 61 73 148 54 10 187 38 179 85 121 210 223 194 86 185 157 17 14 131 40 206 199 56 6 43 27 4 175 244 106 164 63 127 243 219 44 182 247 2 164 92 35 161 137 73 244 230 52 39 201 166 170 244 228 75 182 145 126 197 120 101 62 172 151 91 128 217 189 142 79 4 162 221 81 138 199 76 98 96 34 185 33 78 34)
#f
())
#(183
"composed null"
#vu8(49 50 51 52 48 48)
#vu8(94 49 90 90 2 251 206 20 170 236 132 210 96 183 85 205 175 192 10 156 1 8 118 104 57 209 176 164 18 235 152 37 246 132 17 139 120 216 54 31 163 229 28 227 88 101 79 109 23 154 230 96 170 171 23 247 95 127 120 127 148 71 231 119 30 85 149 147 176 98 27 183 209 105 174 147 110 78 140 133 225 164 106 46 116 54 74 59 60 150 91 38 50 89 251 216 54 235 249 68 235 45 129 202 203 54 117 98 50 53 136 116 83 88 81 21 18 174 185 105 230 173 88 101 198 6 83 83 218 249 209 77 166 38 22 98 40 240 233 177 99 129 210 113 123 104 109 55 163 171 2 192 46 230 115 4 45 249 173 32 76 38 15 53 213 239 20 250 116 217 3 230 183 89 208 197 88 198 152 71 2 103 191 187 188 49 129 199 190 149 249 9 141 33 160 132 188 50 16 130 139 251 50 97 143 60 51 69 247 213 77 201 122 230 157 37 106 209 232 238 76 115 56 41 12 223 175 144 211 83 100 237 62 46 158 33 35 69 241 25 87 30 89 187 15 168 103 169 58 37 115 20 92 158 148 62 110 206 14 11 136 192 17 206 21 198 159 20 61 64 84 176 104 151 165 104 21 3 202 136 130 21 64 68 176 3 57 81 149 242 93 50 145 139 56 3 57 209 62 214 115 251 67 78 58 148 225 4 49 74 121 88 157 83 7 145 121 85 45 67 222 42 24 209 232 73 105 109 71 2 216 201 5 249 207 41 240 248 5 191 40 167 158 232 186 101 87 170 150 208 26 94 228 200 243 215 88 58 45 175 28 83 56 73 15 255 125 194 118 102 154 171 232 141 133 16 38 179 191 104 24 183 193 114 153 226 52 18 244 189 8 74 82 161 96 76 0 56 155 98 157 35 16 201 50 203 134 6 198 218 250 22 243 87 86 91 150 216 175 120 187 235 107 46 16 250 47 87 203 221 227 206 194 179 231 141 63 133 59 237 175 88 251 51 212 85 56 124 230 170 246 233 217 104 29 116 168 139 118 122 207 95 153 203 131 175 230 94 22 124 97 182 254 218 232 147 177 155 217 235 186 140 157 31 121 30 193 98 174 193 94 183 48 28 136 27 243 187 220 172 209 171 77 155 207 3 42 36 114 205 152 252)
#f
())
#(184
"incorrect null"
#vu8(49 50 51 52 48 48)
#vu8(82 24 122 252 97 111 19 114 222 71 196 21 146 253 125 25 191 41 137 172 202 193 22 184 251 78 92 107 25 69 47 115 59 216 144 1 22 159 19 205 165 47 12 56 199 216 66 176 33 115 38 20 91 2 160 42 123 244 31 50 41 207 250 159 214 150 161 82 7 47 226 253 234 201 194 130 149 40 222 230 22 143 8 113 43 159 72 121 244 218 98 127 193 186 23 106 96 73 246 142 0 234 0 232 242 220 183 15 54 189 202 77 253 199 163 61 67 244 80 15 77 199 116 239 181 242 40 105 10 135 231 133 83 173 151 194 212 2 238 146 100 131 145 49 14 206 89 206 236 189 37 181 206 99 10 188 94 6 61 11 25 70 188 68 99 159 34 175 141 58 91 107 94 159 50 44 187 234 250 13 140 232 80 185 51 235 103 83 76 122 36 14 39 43 31 17 123 99 165 157 18 42 22 194 212 92 122 137 27 98 171 46 73 236 240 247 30 112 42 192 34 18 208 17 135 162 1 35 156 143 84 166 241 20 87 74 120 230 99 201 72 22 105 66 189 5 255 141 220 42 98 97 93 203 48 169 197 128 134 2 123 162 195 156 234 103 244 68 12 65 199 20 83 55 131 45 202 217 125 145 175 79 63 167 84 14 24 78 92 48 195 94 36 88 182 228 207 113 61 81 82 9 77 86 114 23 172 3 43 90 167 65 140 89 133 17 174 70 21 35 56 181 37 243 12 169 186 205 216 14 110 78 178 66 214 18 23 175 236 219 95 121 136 186 90 100 64 205 184 33 246 194 189 196 107 115 31 102 250 197 17 82 66 123 114 105 169 28 30 162 179 93 224 185 246 144 165 207 226 154 190 126 18 91 177 174 69 237 120 177 239 126 169 97 5 81 84 245 47 190 182 56 207 114 184 254 211 113 33 27 119 79 113 45 165 235 172 240 183 49 20 97 253 253 134 225 96 21 224 184 90 240 211 128 121 168 7 13 131 4 60 67 126 50 112 101 140 2 62 190 19 25 83 110 173 165 74 129 81 145 171 118 158 65 239 55 149 36 126 70 112 204 183 163 71 135 142 55 63 69 65 137 58 238 151 69 118 30 184 209 197 130 172 48 94 137 158 139 218 226 75 242 238 236 126 74 24 197 253 34 234 6)
#f
())
#(185
"long form encoding of length of digest"
#vu8(49 50 51 52 48 48)
#vu8(145 56 66 204 98 164 26 62 16 88 115 186 196 136 171 110 94 89 113 242 79 56 251 109 153 254 203 27 153 212 117 25 112 75 206 73 135 145 226 158 186 189 239 168 155 2 165 22 233 42 251 222 167 61 57 200 1 160 94 188 123 153 136 183 50 16 61 9 6 79 184 19 125 150 56 59 28 38 27 82 97 76 142 83 22 132 234 15 26 41 192 67 65 154 185 235 134 16 226 181 205 161 171 149 21 181 238 25 186 230 39 191 98 44 140 128 45 110 151 86 94 80 167 253 103 21 239 62 146 27 219 62 12 130 186 30 54 149 65 172 48 55 192 86 249 17 213 212 52 179 255 17 133 211 62 32 149 163 98 113 52 189 110 11 247 225 13 42 122 70 113 44 157 232 113 32 218 235 107 19 234 236 120 212 197 119 165 247 211 63 90 23 229 251 228 140 164 222 121 144 223 0 228 3 207 40 113 5 15 228 157 73 231 179 18 31 72 72 45 53 96 15 92 249 168 54 85 78 224 248 10 186 225 214 55 155 22 131 58 100 184 195 84 248 11 229 121 79 182 214 186 198 225 181 103 145 127 185 3 35 124 121 144 1 70 189 97 32 220 73 205 28 212 140 174 123 132 222 85 136 208 196 167 111 196 203 91 15 107 179 177 161 62 126 107 195 149 216 246 240 114 52 112 211 0 212 82 158 172 26 214 225 178 237 98 214 144 59 214 249 36 117 213 133 80 141 36 44 43 114 15 166 148 176 154 123 102 236 131 49 117 150 238 98 18 35 36 176 22 156 186 21 100 214 193 35 69 255 16 100 114 175 96 95 115 47 182 53 100 108 155 96 141 110 141 206 73 81 184 231 46 86 239 37 237 169 184 232 26 74 107 64 41 79 216 117 67 64 217 202 117 34 116 173 114 174 62 76 187 93 204 133 189 255 57 3 1 111 223 223 24 35 19 78 28 16 57 141 30 222 15 160 223 247 171 99 29 181 161 188 217 67 191 106 42 115 160 63 151 164 245 4 229 232 131 45 247 245 140 155 169 156 84 232 67 164 66 11 151 122 102 2 213 85 253 180 237 41 229 35 115 71 190 55 7 98 26 67 207 128 158 62 195 182 177 192 224 200 206 119 104 239 150 199 244 115 92 6 50 149 110 131)
#f
())
#(186
"length of digest contains leading 0"
#vu8(49 50 51 52 48 48)
#vu8(177 136 191 109 14 247 0 30 218 33 64 149 56 150 13 232 206 103 101 245 42 57 168 134 213 254 78 93 120 84 245 104 136 239 4 184 240 5 67 156 227 219 71 87 33 102 177 55 23 222 76 88 173 49 104 62 56 11 242 58 201 141 92 84 26 165 88 254 199 139 39 192 227 21 252 204 150 15 107 100 69 248 215 50 161 68 218 200 9 128 236 203 107 110 251 125 172 42 163 196 76 112 255 173 13 56 245 12 146 172 183 29 121 159 163 27 126 252 233 25 233 167 231 89 60 134 78 30 177 158 24 115 164 53 155 76 238 21 249 65 251 112 228 237 28 24 15 206 238 100 60 85 243 94 10 14 164 94 218 152 94 213 225 4 182 150 246 219 55 162 29 247 70 147 199 83 17 172 49 178 33 59 171 250 71 63 171 44 94 175 245 176 3 38 77 138 31 174 104 183 1 135 157 139 247 209 138 247 242 56 14 81 55 68 183 238 190 30 232 63 100 144 202 198 251 71 150 45 89 178 211 4 169 32 215 218 200 139 5 38 2 41 161 120 246 25 107 192 151 115 5 166 249 222 138 165 143 98 117 223 20 234 66 211 170 116 208 103 96 167 18 162 87 178 225 231 168 62 15 65 189 156 29 164 247 109 118 52 248 169 194 234 102 202 31 22 216 45 39 181 93 85 88 99 153 131 140 60 188 82 60 47 88 142 29 231 43 15 8 173 120 44 90 166 242 143 94 175 94 176 77 203 229 183 79 181 179 254 204 153 135 115 48 206 167 200 188 159 45 153 0 108 15 68 248 144 135 22 236 142 179 195 39 49 4 65 141 197 176 217 5 147 221 248 215 59 253 200 131 223 165 243 171 250 151 120 97 20 127 222 222 213 93 76 230 122 39 188 143 104 254 64 124 184 111 85 101 135 152 136 178 7 87 110 5 83 77 208 198 229 239 48 169 247 212 157 251 45 80 35 227 24 198 81 42 28 145 214 163 137 97 174 150 129 254 152 170 203 129 128 42 178 65 95 247 136 151 99 50 158 172 138 99 2 69 240 172 189 45 41 209 138 95 91 114 97 224 55 155 243 53 231 80 198 164 151 208 114 95 45 239 158 79 2 80 228 13 209 28 98 164 244 190 227 202 210 234 163 97 175 207 6)
#f
())
#(187
"wrong length of digest"
#vu8(49 50 51 52 48 48)
#vu8(136 234 124 126 189 43 135 173 9 9 243 195 44 212 164 96 211 58 150 251 126 92 47 163 83 36 94 47 38 171 26 98 64 200 149 206 40 201 74 247 40 157 53 152 54 255 89 220 99 69 86 187 172 150 137 211 59 185 81 92 236 215 51 72 122 62 59 84 64 24 123 219 213 36 133 61 81 2 197 0 151 93 183 82 82 185 104 6 53 13 135 94 249 51 246 76 202 179 81 20 49 40 173 129 227 160 37 113 229 180 4 142 197 139 90 143 119 78 165 102 63 19 243 232 15 148 82 214 120 4 193 66 176 95 242 188 17 222 29 43 160 236 11 46 94 15 51 0 6 254 190 31 180 112 201 58 66 74 5 225 64 41 131 71 135 216 95 59 157 42 10 80 138 144 208 12 147 174 118 236 10 144 9 52 79 55 196 51 238 21 236 72 49 160 241 76 82 34 146 140 47 74 240 230 245 129 167 123 60 140 172 207 95 97 228 111 197 100 253 46 248 194 159 108 224 114 87 73 157 112 194 134 18 71 227 254 3 124 185 134 167 130 83 107 75 240 92 161 134 224 47 165 165 70 123 17 161 111 129 230 213 235 149 2 229 215 79 178 7 48 108 27 202 68 52 128 183 251 105 34 33 82 84 56 146 248 212 82 30 24 166 54 144 211 146 222 200 13 181 159 158 57 31 27 30 183 51 6 34 104 249 229 217 223 114 113 178 159 250 235 88 86 59 241 234 237 231 70 120 129 152 175 218 207 213 68 61 236 33 230 56 225 234 243 35 65 194 222 230 162 164 107 26 34 210 11 28 46 198 152 254 251 91 187 235 57 80 225 241 110 117 87 143 190 252 245 206 42 101 162 72 215 219 174 191 108 90 194 50 7 239 123 241 171 15 82 207 13 174 217 152 2 46 252 109 211 19 36 57 230 155 146 8 171 177 109 254 77 117 160 184 126 220 212 51 166 43 43 226 132 166 141 145 206 14 152 125 91 121 190 198 146 79 210 76 192 48 178 114 10 135 251 255 9 186 242 6 144 220 237 206 83 186 112 162 79 204 175 137 254 123 214 231 10 148 201 87 169 16 4 77 67 75 131 38 196 205 60 248 93 42 194 204 65 164 168 111 51 105 117 221 183 50 41 234 28 70 193 99 122 50 121)
#f
())
#(188
"wrong length of digest"
#vu8(49 50 51 52 48 48)
#vu8(53 249 177 69 193 235 225 228 106 222 45 92 35 212 33 249 68 252 9 62 189 45 224 30 74 57 73 84 181 83 49 201 22 16 28 227 94 238 182 137 78 26 164 29 224 152 224 118 177 142 37 143 36 169 97 69 129 23 107 169 165 82 9 147 217 244 206 239 164 9 67 177 146 190 11 57 226 123 108 182 220 151 36 52 217 145 80 239 7 55 168 242 206 218 131 83 1 63 14 116 69 93 236 230 224 54 65 104 102 27 31 57 76 51 245 84 61 119 0 95 238 235 247 45 189 94 85 61 194 74 241 214 242 32 66 173 183 255 90 236 28 164 216 8 180 144 222 209 250 134 125 21 144 155 114 60 192 216 44 69 224 212 219 172 116 89 1 214 249 140 115 176 252 100 189 1 45 78 201 75 179 83 123 64 153 101 95 62 55 186 63 217 175 160 242 121 81 245 124 136 218 192 101 142 115 233 98 47 172 88 38 251 249 56 107 218 122 197 156 54 202 19 80 165 99 146 21 198 197 221 156 34 34 26 143 71 244 19 88 58 8 182 231 211 72 219 85 45 177 157 251 36 82 118 86 109 249 105 143 163 104 85 73 237 147 185 87 136 201 24 220 77 59 55 235 108 121 163 2 11 182 28 220 119 2 66 50 93 24 178 16 129 80 121 104 174 144 41 137 134 144 58 85 215 243 228 253 121 178 27 177 230 105 102 42 156 62 83 248 212 58 162 1 230 90 162 221 224 119 135 68 178 73 110 162 217 206 242 9 155 104 180 9 11 141 215 49 113 239 149 170 237 7 196 9 75 168 66 235 212 21 94 45 1 110 232 114 89 59 218 127 2 12 89 243 145 26 145 217 244 181 45 186 154 71 88 59 190 87 251 246 96 60 114 117 222 127 73 164 22 68 5 121 202 147 254 221 98 109 82 206 159 170 81 237 197 80 42 159 40 186 231 128 231 92 185 47 194 169 69 62 114 153 215 120 55 69 215 190 215 179 209 229 66 36 242 47 38 102 143 241 41 238 123 100 244 240 101 172 149 180 202 174 221 180 40 3 91 233 87 138 181 18 2 188 227 33 99 165 242 177 72 2 105 143 104 146 22 217 204 1 143 241 243 51 17 240 117 141 153 34 58 15 207 179 213 230 180 81 239 120 44)
#f
())
#(189
"uint32 overflow in length of digest"
#vu8(49 50 51 52 48 48)
#vu8(192 50 105 216 158 248 81 177 71 31 172 244 5 118 164 230 234 193 106 201 213 48 247 11 27 138 243 154 61 136 91 38 60 137 53 54 201 67 161 68 147 150 195 131 137 255 203 234 168 186 232 98 47 179 39 162 25 30 172 39 193 221 104 44 64 236 251 189 151 127 121 136 80 146 85 165 120 121 148 11 30 112 248 240 37 35 53 225 40 240 146 181 1 87 170 236 134 180 107 12 177 93 193 218 5 165 147 18 74 25 169 104 137 223 35 182 245 198 226 146 80 87 224 67 138 167 154 205 143 232 240 47 233 191 96 66 102 142 158 141 178 178 234 166 120 146 230 24 82 83 62 85 106 181 104 13 179 219 148 160 152 198 94 91 69 82 107 234 38 194 128 156 64 104 113 188 50 219 134 134 48 137 2 6 195 173 58 200 62 222 49 216 145 23 36 175 12 214 69 167 207 153 112 28 68 242 93 78 113 125 227 142 138 105 114 201 149 108 161 77 23 246 100 132 166 224 156 41 73 17 229 202 112 253 41 204 48 153 99 159 55 232 50 233 186 174 0 49 183 240 226 130 85 20 104 59 106 11 56 6 3 84 198 237 239 109 153 15 34 202 136 21 75 42 31 170 208 255 36 154 123 110 111 250 93 90 27 118 83 79 76 139 252 48 91 178 40 114 203 118 45 8 20 133 131 44 231 78 153 84 251 79 105 145 227 185 173 234 13 114 136 147 213 81 30 168 10 116 86 45 18 108 185 30 29 5 150 33 223 46 97 245 158 240 139 143 29 191 97 239 90 152 59 22 129 72 179 207 245 189 143 204 115 99 0 85 251 80 236 128 13 225 161 183 88 218 163 157 121 241 122 174 119 144 255 146 199 96 212 40 106 245 138 142 239 102 158 88 45 68 215 114 191 244 250 54 217 152 177 167 15 58 87 197 48 211 177 65 108 20 87 144 62 215 96 248 58 43 33 28 105 207 217 157 42 25 203 96 75 198 131 30 245 35 56 152 95 191 111 14 214 87 3 75 220 92 181 40 245 118 174 172 119 80 7 23 255 124 174 90 235 214 232 229 182 231 112 123 171 199 158 15 241 1 247 39 39 66 75 186 138 155 80 48 77 191 56 67 198 61 74 71 0 213 68 213 94 27 134 52 215 90)
#f
())
#(190
"uint64 overflow in length of digest"
#vu8(49 50 51 52 48 48)
#vu8(206 130 16 34 128 122 183 15 41 255 138 213 84 147 77 78 230 219 188 151 7 59 175 209 123 22 167 45 67 238 54 145 120 128 72 175 209 106 120 31 200 196 142 108 79 225 100 165 15 254 217 172 171 195 19 83 27 119 164 227 251 219 43 254 115 1 107 63 88 218 88 138 152 184 103 11 148 219 95 33 242 154 196 117 196 36 108 27 123 176 109 19 98 80 245 231 12 211 239 208 173 229 161 7 239 246 77 108 2 105 148 153 53 228 119 145 97 224 224 4 124 95 246 25 27 179 167 174 156 1 136 161 146 136 7 214 148 224 229 214 14 110 4 171 110 192 37 217 88 249 126 159 210 255 155 193 6 134 0 220 210 39 191 2 236 55 129 30 72 194 198 150 50 118 161 87 192 186 88 11 83 71 212 71 38 98 111 89 219 109 176 61 36 112 180 2 50 92 17 115 147 154 150 220 203 67 140 129 39 138 122 158 206 197 22 55 210 0 62 167 77 102 38 42 56 155 9 55 213 88 109 196 216 216 97 117 98 91 206 231 33 27 166 178 160 55 161 86 244 94 180 80 7 63 129 61 76 213 189 126 208 46 85 203 175 17 44 193 34 29 169 160 225 51 115 53 97 136 78 168 46 41 95 135 120 96 62 156 67 129 89 238 254 234 167 230 23 108 18 135 168 135 217 126 211 148 205 55 131 45 184 55 195 54 189 225 84 213 37 234 81 144 208 128 63 226 184 159 18 172 141 7 68 220 2 182 136 145 80 100 250 38 9 49 252 13 70 194 198 48 180 238 196 141 245 158 142 237 73 170 129 249 3 168 250 154 53 184 61 199 10 182 88 232 207 156 155 93 208 177 46 196 180 24 127 247 22 141 213 245 135 141 26 206 28 93 16 31 156 173 48 18 96 11 49 147 194 150 140 194 154 111 177 35 198 64 165 86 197 104 134 127 138 24 179 103 164 92 250 51 150 21 201 58 23 13 219 229 151 138 249 195 90 32 237 115 41 222 130 202 193 48 68 40 19 196 4 194 22 91 211 36 55 253 188 246 234 207 43 7 223 124 221 99 127 99 203 12 160 253 66 126 246 98 146 85 156 181 170 227 142 79 51 64 11 137 209 173 235 122 15 64 244 221 15 42 231 151 2 192 253 184)
#f
())
#(191
"length of digest = 2**31 - 1"
#vu8(49 50 51 52 48 48)
#vu8(5 107 4 34 163 197 47 237 59 66 69 230 215 85 87 129 13 6 5 223 150 48 193 200 44 43 46 43 253 211 50 26 94 93 39 165 192 158 91 171 202 156 72 159 16 76 23 209 177 133 214 226 228 113 148 8 105 198 83 18 200 197 252 59 204 223 151 184 58 3 7 132 124 129 188 119 90 32 134 50 124 130 95 6 60 197 174 66 28 236 175 208 6 81 235 155 68 4 232 113 79 248 125 117 62 38 77 145 239 53 12 65 249 215 139 244 128 130 254 112 222 100 178 157 161 27 19 155 180 252 48 87 215 217 86 192 134 58 30 244 231 61 253 239 136 199 116 97 117 41 138 39 173 36 125 100 51 243 50 141 77 205 129 103 76 197 128 5 178 56 61 23 87 0 121 138 85 176 141 64 54 6 111 138 66 224 33 164 85 167 83 145 26 38 160 210 137 247 254 14 46 71 191 245 233 234 105 10 93 178 46 120 148 95 208 131 55 49 66 120 179 156 12 121 60 251 23 86 114 79 41 167 48 53 92 150 156 234 225 178 245 241 40 55 95 37 87 187 159 119 196 212 160 221 91 55 84 53 175 176 186 87 233 168 83 94 139 24 99 154 213 148 195 142 215 127 83 228 65 205 198 176 152 39 237 156 253 46 238 61 139 234 149 15 54 215 7 238 217 143 77 206 218 181 142 248 102 230 31 191 165 250 18 164 46 119 108 236 147 25 229 120 163 236 104 120 191 206 203 7 49 64 176 193 205 58 59 87 183 52 31 116 58 56 203 32 49 54 164 156 176 55 238 174 52 221 219 208 254 43 73 90 80 133 103 81 79 158 210 246 99 50 90 167 81 220 104 157 183 228 251 249 74 74 66 236 228 183 254 199 186 27 50 195 132 203 91 8 62 61 61 173 173 241 237 48 58 79 59 101 54 246 72 182 73 21 235 161 40 120 35 131 76 224 254 158 119 38 232 113 74 223 202 83 73 62 213 130 132 73 241 115 126 61 11 51 66 126 74 27 52 52 18 114 168 169 235 206 120 64 42 190 68 22 41 45 122 167 227 66 64 47 146 202 82 132 54 159 200 133 11 202 214 94 56 175 56 72 165 220 238 184 179 194 51 115 85 225 4 166 248 137 32 121 252 77 20 11 22 90 236 224)
#f
())
#(192
"length of digest = 2**32 - 1"
#vu8(49 50 51 52 48 48)
#vu8(219 65 69 152 212 196 56 127 34 89 52 253 94 76 114 8 79 241 7 34 204 137 141 197 28 44 29 69 41 75 41 206 113 42 83 160 155 113 1 8 129 26 70 179 56 152 224 252 186 178 129 224 41 21 47 206 11 92 41 168 54 101 37 44 127 32 89 147 225 241 61 159 102 232 30 110 147 148 184 47 16 120 113 203 189 114 164 79 4 188 212 51 237 68 224 92 51 2 155 11 90 209 225 208 224 201 227 24 194 201 182 112 120 177 75 117 34 44 22 33 147 99 95 109 250 18 4 41 177 224 164 144 61 158 220 59 80 57 9 64 63 32 135 243 241 238 224 150 40 238 123 116 72 154 153 171 227 183 199 246 215 109 206 166 9 3 95 89 65 148 238 60 55 14 145 214 242 61 93 57 114 53 176 116 120 166 27 249 131 97 123 153 154 57 186 249 176 8 243 75 97 94 204 42 107 241 147 101 70 222 218 178 182 8 32 102 235 243 113 63 107 163 191 209 55 51 150 74 141 172 162 115 251 44 193 31 9 101 142 210 13 224 144 149 101 94 172 35 28 81 65 85 61 95 247 207 31 185 11 74 247 62 18 99 91 25 2 112 219 70 18 160 227 231 40 210 243 233 73 91 238 203 95 5 178 211 178 53 223 184 35 225 196 219 213 182 148 77 5 241 9 135 166 238 170 20 113 48 116 131 250 15 8 155 26 244 241 98 238 210 5 103 199 30 174 120 244 164 9 68 47 5 232 70 95 231 150 252 231 178 186 111 247 41 213 104 141 4 212 175 15 103 48 131 106 188 21 22 195 203 198 12 41 233 136 62 242 112 89 30 152 88 141 162 177 100 175 164 84 14 119 7 191 22 33 99 181 101 98 84 19 107 2 191 19 67 247 91 3 162 142 87 209 205 171 210 13 10 59 0 67 216 6 113 35 94 143 97 119 72 212 197 226 229 116 55 111 107 74 243 212 217 34 43 15 102 11 15 162 78 197 61 85 50 218 243 52 185 218 110 93 165 27 7 36 149 121 52 107 152 125 25 72 27 165 1 35 125 130 176 218 135 187 143 105 97 84 120 188 159 175 64 242 109 25 11 93 209 96 202 117 34 104 66 219 55 0 128 192 232 97 169 68 249 127 202 238 103 61 177 223 242)
#f
())
#(193
"length of digest = 2**40 - 1"
#vu8(49 50 51 52 48 48)
#vu8(17 40 61 188 6 57 109 76 65 212 71 150 255 167 158 243 80 64 112 61 239 45 209 91 89 26 188 164 1 224 146 158 160 238 216 40 184 196 149 230 60 19 234 110 179 155 100 108 145 165 115 104 217 63 109 53 70 232 117 181 115 208 93 83 143 233 188 28 245 104 72 138 161 80 145 58 197 208 67 73 137 231 189 205 134 54 62 160 86 215 217 95 65 216 222 73 38 134 28 146 82 179 69 222 120 152 111 220 246 41 64 252 83 186 221 227 106 200 22 24 51 110 52 92 194 113 23 83 58 46 109 146 163 27 143 222 189 93 61 67 159 9 248 104 212 160 219 192 148 101 22 189 131 56 6 247 34 105 139 29 107 62 115 87 96 93 45 23 84 244 184 131 113 200 79 196 90 201 219 170 131 193 244 144 241 197 168 110 164 21 70 101 173 191 157 174 67 137 132 241 199 178 53 125 109 197 27 183 218 95 73 98 247 189 177 31 60 209 235 80 45 174 34 124 97 18 61 157 98 254 142 233 3 70 96 26 12 223 240 55 67 87 111 171 182 233 63 251 88 130 212 14 74 205 65 216 221 64 129 144 33 67 45 3 90 217 129 222 30 129 106 82 142 49 198 240 103 13 89 206 232 12 15 81 104 124 39 230 0 189 223 244 63 78 21 87 119 69 211 70 133 198 54 235 241 124 25 23 192 39 22 186 178 101 150 128 10 67 184 14 106 70 191 222 51 70 148 91 175 18 40 58 201 192 63 208 168 182 147 173 141 164 133 118 22 145 50 183 48 246 8 237 96 57 14 252 26 240 158 103 89 217 186 196 154 155 91 170 38 47 7 31 33 247 1 255 12 235 176 50 178 167 85 198 171 84 149 233 108 91 210 140 140 57 86 185 62 179 83 238 166 252 131 44 182 217 163 218 59 25 171 182 189 253 248 67 13 233 115 223 160 32 6 193 16 168 186 205 112 91 44 240 41 55 131 114 143 206 243 250 243 191 105 25 117 172 231 114 173 79 57 198 55 45 143 238 119 96 188 136 103 230 178 206 207 46 128 102 122 213 47 241 213 29 200 239 54 18 4 230 108 23 55 177 162 237 66 136 59 1 172 102 81 119 222 220 150 212 54 184 120 10 20 189 105 177 57 140 44 39 187 198)
#f
())
#(194
"length of digest = 2**64 - 1"
#vu8(49 50 51 52 48 48)
#vu8(223 52 177 248 244 91 247 243 4 37 216 30 139 247 89 171 2 96 83 48 213 202 51 78 210 53 139 112 152 50 12 140 210 203 57 59 143 205 207 62 52 181 151 158 141 167 163 155 147 25 247 93 140 203 127 202 78 103 233 42 141 25 212 89 123 204 239 243 149 169 242 123 155 151 7 78 69 186 127 4 29 70 78 84 48 23 166 8 182 171 206 251 77 69 115 235 134 66 120 223 206 250 113 214 9 186 111 128 108 149 23 43 183 38 47 111 63 229 134 216 25 182 214 71 73 9 184 192 56 102 196 61 79 192 106 2 143 48 213 116 171 160 66 207 213 63 51 166 197 241 124 235 100 32 24 212 246 95 66 156 79 25 147 196 60 5 42 121 98 151 165 55 74 119 72 93 229 55 163 211 249 74 132 145 51 103 169 10 27 37 233 145 138 174 138 26 249 47 204 106 22 110 144 251 165 121 147 75 4 204 63 119 185 240 10 133 247 201 236 11 253 206 37 58 115 89 145 7 86 126 115 221 15 126 172 238 250 70 143 100 68 190 9 232 245 152 177 151 222 93 129 219 60 84 237 24 191 99 120 20 91 49 132 36 115 56 156 156 129 138 197 115 42 243 8 95 68 242 210 115 188 196 233 254 57 218 193 136 101 143 148 240 42 245 248 10 25 35 59 95 33 15 234 132 214 134 71 9 255 215 38 217 230 215 92 230 83 178 178 198 40 163 85 208 171 237 231 74 57 162 255 252 201 115 138 55 186 185 13 79 208 165 182 37 230 149 252 54 210 137 56 94 33 37 181 90 77 55 118 235 66 243 140 24 233 235 34 49 221 205 204 164 0 179 102 215 18 170 20 10 29 156 166 175 55 68 250 185 92 239 144 121 201 183 185 171 232 185 61 100 176 173 125 160 122 198 25 138 73 127 196 248 39 227 0 169 141 107 87 44 137 227 151 179 252 108 68 49 104 178 63 237 162 152 105 21 210 127 200 87 146 76 197 174 57 255 61 221 53 113 120 204 31 228 229 125 220 27 191 21 72 145 42 13 100 233 112 238 65 105 176 78 36 194 31 221 139 144 70 166 192 127 220 241 145 209 102 145 170 9 29 133 71 113 124 64 55 77 225 112 104 96 118 39 93 146 49 233 7 67 96 77)
#f
())
#(195
"incorrect length of digest"
#vu8(49 50 51 52 48 48)
#vu8(39 196 227 244 177 175 173 207 15 207 69 95 41 115 240 194 97 147 79 62 72 118 2 13 145 16 106 27 41 9 229 231 118 90 231 105 9 243 58 63 180 7 136 181 3 48 236 152 55 100 210 105 45 9 246 60 251 15 177 9 163 44 121 156 173 60 31 108 239 64 149 154 71 235 152 140 54 76 133 167 15 109 235 196 173 191 201 207 94 50 43 68 102 166 207 50 114 248 151 240 114 98 108 97 233 216 11 94 143 96 92 113 219 10 93 248 55 148 155 2 61 156 208 132 183 79 9 160 71 201 120 34 242 217 202 20 11 74 31 118 54 212 158 10 183 45 62 6 147 93 103 186 174 186 126 170 126 44 4 33 96 32 206 132 179 184 244 36 164 111 97 95 21 71 5 26 242 217 192 235 55 165 150 123 119 189 52 85 243 43 2 156 19 119 189 184 188 36 185 113 90 78 208 73 1 209 23 172 60 46 36 58 208 16 116 239 243 92 114 242 59 21 139 4 224 235 81 67 65 126 97 26 89 51 240 133 22 30 159 153 234 206 28 6 235 10 18 240 170 14 24 34 44 63 159 170 83 101 27 88 125 72 193 180 85 238 65 181 123 111 181 146 116 75 51 28 11 97 150 47 226 248 224 17 220 137 20 134 188 31 147 202 183 97 212 139 40 99 85 133 33 126 214 82 204 34 183 237 212 51 34 106 98 104 84 5 224 134 223 124 186 41 66 183 40 238 33 205 61 239 161 128 134 95 193 218 4 237 170 253 134 84 111 132 228 86 159 118 60 205 112 245 96 248 56 220 173 86 134 137 103 218 137 166 39 29 142 93 174 204 155 129 210 132 143 141 167 34 54 40 208 22 246 168 200 183 222 188 111 199 244 87 243 31 216 215 232 220 129 169 170 130 107 21 86 158 158 40 249 178 216 7 40 143 24 240 143 36 236 171 137 229 216 41 198 74 122 47 48 74 75 68 225 232 73 102 147 75 134 230 216 27 36 137 239 160 90 114 252 135 6 70 11 48 84 6 231 52 1 48 19 42 126 22 213 131 13 234 51 44 120 184 216 218 115 85 112 82 178 46 89 56 154 23 249 186 54 119 167 141 104 94 212 53 233 110 237 16 192 115 244 80 160 199 32 173 51 117 148 110 25 211)
#f
())
#(196
"lonely octet string tag"
#vu8(49 50 51 52 48 48)
#vu8(186 222 111 4 188 203 8 177 108 118 248 144 90 123 132 135 112 94 28 18 152 208 185 179 136 48 20 1 84 87 230 86 56 228 172 49 213 194 200 136 149 195 67 90 90 221 126 47 16 117 81 240 53 252 130 63 31 148 146 231 246 38 41 53 124 240 61 137 156 144 240 156 230 240 85 167 3 192 166 93 203 171 135 144 88 151 93 156 247 201 3 110 21 88 39 138 8 92 154 205 122 14 55 221 245 242 57 93 81 204 99 18 32 87 23 185 129 128 106 221 28 168 218 139 250 58 185 99 36 95 83 71 17 177 165 34 48 19 39 4 39 167 244 40 44 66 0 138 29 104 40 10 42 157 204 43 97 116 32 19 174 182 187 162 36 6 222 178 176 24 148 228 17 126 144 9 63 36 86 187 89 9 50 13 87 155 43 205 53 180 142 82 86 217 31 108 47 69 235 14 201 125 82 56 180 39 187 25 149 197 211 150 241 193 246 252 197 181 29 128 237 97 150 27 30 3 29 70 119 65 94 154 31 124 59 17 134 68 38 217 103 247 255 232 157 88 214 222 0 206 162 147 61 210 239 208 24 215 244 44 131 37 146 28 9 187 76 118 57 55 156 187 34 216 44 205 110 139 108 232 243 9 215 172 59 76 232 54 183 163 194 225 10 34 35 91 75 106 248 85 6 155 252 43 232 197 9 160 92 80 28 189 213 187 118 120 31 106 33 187 229 65 36 221 69 233 65 154 127 110 204 169 85 89 52 11 17 29 120 121 181 91 32 169 182 108 203 14 251 10 194 128 160 175 90 80 135 84 139 109 213 117 19 212 117 249 157 35 9 225 216 19 48 59 3 23 245 9 178 112 224 22 207 89 142 218 84 1 140 4 221 155 89 49 198 110 215 81 163 128 150 187 125 13 55 152 154 156 50 154 62 97 76 31 235 42 69 237 153 194 205 50 37 131 81 185 138 50 131 164 137 192 107 181 167 101 141 192 157 125 80 201 235 154 151 121 244 52 114 196 106 72 7 26 173 12 147 188 8 251 196 34 164 178 19 15 49 9 154 122 139 106 165 57 21 196 72 198 225 6 32 8 166 179 219 19 150 237 151 33 254 162 35 44 41 183 118 104 245 144 255 145 166 169 23 27 69 252 73 138 128 208)
#f
())
#(197
"appending 0's to digest"
#vu8(49 50 51 52 48 48)
#vu8(224 254 26 170 46 31 58 159 173 105 223 196 123 89 252 75 122 98 254 128 157 96 27 126 24 152 235 29 71 87 175 34 114 6 68 70 88 52 104 219 76 5 121 194 49 42 226 219 203 143 83 227 231 117 224 11 108 66 47 23 174 173 118 92 252 123 172 155 217 161 172 149 206 23 71 22 99 31 20 54 244 24 248 125 74 12 34 162 57 221 253 111 202 65 0 167 255 93 172 90 10 202 45 68 91 223 138 14 3 103 97 45 140 164 182 102 191 216 236 17 204 26 89 116 188 57 204 235 48 35 226 110 213 130 8 159 244 201 225 33 16 79 229 229 74 21 1 54 67 238 225 15 221 6 63 126 200 160 97 125 105 184 128 165 12 76 83 117 155 117 187 115 100 232 80 90 99 14 14 200 88 85 69 63 6 105 5 29 149 193 70 54 0 95 88 132 223 255 237 192 66 182 129 113 179 53 202 140 26 13 145 56 188 72 179 251 220 114 178 42 121 240 90 203 161 209 169 90 76 117 8 207 42 14 114 145 87 93 167 240 237 59 205 191 133 172 14 92 159 113 120 17 163 103 4 95 19 246 196 100 1 24 71 56 209 56 227 16 183 182 33 128 237 113 212 223 5 24 28 102 54 55 70 103 212 192 138 149 72 69 254 143 215 251 28 252 4 235 103 62 95 118 201 161 89 145 152 109 60 187 10 254 232 129 36 167 5 187 220 8 117 213 253 3 126 238 177 110 132 41 109 166 93 182 22 251 245 63 245 123 3 121 190 73 2 178 110 138 217 246 216 228 154 136 152 123 166 88 103 59 242 75 218 53 133 84 132 42 97 114 177 101 111 237 45 203 125 55 206 215 242 93 185 235 111 30 7 238 106 49 49 67 199 172 252 175 70 96 52 203 247 210 230 89 141 234 106 77 218 219 95 246 179 197 149 233 146 77 243 89 66 197 58 251 72 148 102 157 231 175 10 77 11 162 187 4 95 9 105 1 101 150 89 10 50 51 193 58 254 138 245 164 240 62 71 163 228 177 49 2 87 171 109 66 187 120 82 126 127 54 49 77 11 243 126 109 53 35 79 248 190 151 145 105 74 78 1 134 114 103 132 131 133 159 79 228 132 113 142 50 78 29 117 61 144 233 93 188 240 39 56 85)
#f
())
#(198
"prepending 0's to digest"
#vu8(49 50 51 52 48 48)
#vu8(210 252 79 26 156 45 142 194 144 10 95 63 209 113 232 105 189 16 169 225 190 139 12 234 229 88 26 215 123 46 62 212 44 14 28 31 100 226 200 19 208 170 101 12 171 68 48 57 252 144 150 179 106 194 1 77 139 163 164 202 15 22 246 76 27 97 177 75 125 2 71 131 98 40 179 196 201 82 6 102 182 151 30 150 144 150 221 67 29 132 103 65 77 26 253 203 157 241 151 168 225 152 86 147 222 108 137 51 4 150 68 220 191 42 216 24 96 11 22 215 114 3 100 140 211 190 150 57 63 143 189 194 207 136 93 242 203 238 254 39 184 203 72 126 234 247 90 44 5 161 143 14 128 103 198 13 203 237 51 13 208 140 62 55 112 141 178 226 240 100 125 232 249 55 13 176 123 71 37 181 148 170 35 228 197 217 145 169 157 90 136 151 152 229 151 78 120 60 135 223 92 192 37 176 230 109 113 140 118 178 151 124 127 183 52 179 22 40 177 2 210 128 133 64 70 146 60 195 18 119 224 26 85 103 223 104 17 255 237 195 107 81 49 193 77 73 236 182 176 123 177 2 98 220 36 204 131 11 164 127 248 3 125 149 221 13 179 231 91 124 11 202 206 128 18 193 33 50 136 157 91 252 104 114 138 183 87 63 207 199 192 220 160 164 159 110 54 3 249 17 251 12 56 101 175 229 42 46 31 69 173 136 11 139 215 216 109 197 73 252 76 105 116 98 208 228 224 23 163 7 115 35 81 172 205 159 54 180 225 81 85 76 111 252 48 11 12 193 169 174 155 81 123 203 163 242 24 63 188 37 127 239 33 222 26 172 93 136 199 202 209 20 91 210 13 9 225 45 117 123 211 201 249 102 111 249 244 88 206 126 160 98 114 216 152 184 232 104 145 5 246 153 210 246 52 68 206 30 16 233 1 19 75 32 15 129 66 74 59 1 174 196 2 99 33 24 250 16 59 54 186 103 166 164 44 172 151 105 219 159 0 19 81 26 67 109 100 202 43 180 247 125 179 199 78 228 93 26 116 92 169 182 8 11 173 191 111 226 195 127 184 22 20 5 251 199 144 74 52 140 205 56 138 251 35 96 16 153 197 155 200 25 35 30 174 152 193 201 163 147 120 14 168 154 83 129 166 94 198 30 163 198)
#f
())
#(199
"appending null value to digest"
#vu8(49 50 51 52 48 48)
#vu8(137 221 202 189 86 26 79 128 97 148 184 148 108 142 229 118 60 69 128 80 25 86 76 246 156 105 136 79 81 57 231 190 154 187 10 108 43 191 87 246 221 181 221 76 172 164 120 188 187 160 228 122 250 13 129 26 145 160 148 143 150 144 31 230 52 60 89 118 151 24 197 23 249 113 201 84 217 176 168 16 38 182 57 24 57 218 60 247 222 218 132 37 69 76 160 153 244 247 114 222 148 48 107 117 233 47 151 7 10 22 213 207 255 20 70 97 122 198 51 29 226 24 194 188 232 14 65 70 238 16 154 67 68 188 249 224 243 164 180 135 149 70 129 210 245 90 58 31 111 166 204 74 140 197 53 166 42 161 79 140 219 102 73 220 19 35 237 98 135 17 145 191 240 194 155 46 23 89 58 79 252 211 244 83 253 224 44 250 37 41 38 216 0 212 165 199 97 152 249 209 120 187 91 14 161 20 42 137 234 253 82 7 11 74 7 54 103 170 92 155 194 205 11 19 237 34 227 245 238 190 208 40 147 130 143 235 144 219 68 208 251 217 205 11 126 238 209 180 111 70 91 19 16 115 177 162 241 231 251 187 203 63 182 129 177 210 42 202 237 220 103 131 64 125 211 73 165 147 203 168 145 245 202 162 50 142 88 18 171 227 112 160 23 67 110 37 242 141 177 97 123 188 102 202 194 111 87 34 240 185 215 142 191 89 170 65 111 65 244 77 164 96 53 174 2 226 129 127 245 61 75 159 83 227 77 129 121 94 77 47 209 203 223 57 147 148 41 56 163 35 242 168 192 87 96 217 195 234 230 6 152 161 163 136 82 188 216 32 109 90 71 195 187 98 254 2 127 240 182 153 195 59 3 30 188 242 117 220 49 249 11 120 6 51 219 10 206 175 207 40 178 94 97 140 59 57 147 121 79 77 210 166 64 114 149 216 14 159 239 234 16 10 240 107 0 129 86 98 133 90 157 91 27 186 149 36 23 241 120 116 128 180 226 45 211 249 251 236 4 253 139 131 233 239 101 144 246 215 56 127 62 153 26 179 185 140 200 142 155 60 98 92 120 200 6 117 42 124 236 33 170 6 51 75 172 174 57 57 45 0 159 84 228 245 211 161 43 110 138 147 69 6 39 60 32 89 99 43 189 87 221 23)
#f
())
#(200
"truncated length of digest"
#vu8(49 50 51 52 48 48)
#vu8(175 219 139 76 251 36 11 78 248 188 27 32 44 3 140 168 81 25 190 28 72 255 122 230 3 159 241 166 212 110 38 40 103 8 236 139 252 58 151 38 48 79 148 75 216 43 103 32 29 123 236 206 154 20 116 65 186 142 185 206 234 54 158 0 79 112 44 41 181 159 174 177 229 239 199 45 91 163 249 137 103 43 23 12 193 175 223 119 81 26 154 33 120 182 225 74 0 138 43 52 123 92 140 71 239 230 140 107 68 216 108 101 185 219 217 151 191 66 209 67 252 188 185 0 72 201 40 96 68 142 106 232 147 154 221 35 251 229 204 174 86 42 2 223 159 150 129 190 1 109 45 144 169 108 119 251 36 28 131 139 31 84 82 106 26 220 175 240 166 254 80 37 76 155 92 107 61 253 0 144 104 73 222 213 251 106 176 108 34 71 63 71 18 136 199 69 181 145 25 85 104 165 202 82 242 95 120 147 235 149 177 122 8 23 99 206 102 232 73 13 219 181 136 254 35 184 201 211 57 52 141 248 27 118 153 99 31 219 32 117 107 141 145 94 124 250 58 32 187 90 100 60 144 162 219 188 151 20 42 76 160 145 88 154 2 34 196 89 184 115 142 253 228 153 223 161 14 114 159 134 58 164 43 16 161 153 244 57 91 240 209 49 193 56 145 5 1 71 219 81 200 51 63 166 242 208 33 162 99 223 55 221 16 228 178 100 223 20 70 87 233 200 191 35 23 80 121 239 76 154 36 181 97 128 109 147 4 160 243 66 174 79 250 105 146 91 98 155 246 89 72 229 48 86 186 136 145 222 248 177 184 39 248 106 29 166 153 69 144 123 219 54 91 98 123 180 127 52 50 97 99 24 22 74 117 30 232 86 145 239 10 32 253 122 62 97 193 172 196 194 208 139 218 91 154 35 167 17 155 139 25 51 175 86 73 125 6 175 70 39 235 99 237 79 168 202 186 205 112 196 46 154 46 99 136 99 222 17 56 243 50 209 221 200 162 75 67 105 212 96 93 172 212 223 150 177 7 82 53 209 13 222 201 62 19 162 4 136 186 155 100 155 234 21 214 154 48 199 22 249 98 17 159 49 146 123 244 173 87 65 167 57 203 183 148 182 142 65 3 188 5 254 48 135 125 84 4 151 108 93 224 185)
#f
())
#(201
"Replacing digest with NULL"
#vu8(49 50 51 52 48 48)
#vu8(227 66 136 255 25 109 144 238 213 146 92 129 168 160 18 122 191 208 240 222 85 9 72 246 59 224 246 8 150 237 110 215 196 116 181 68 166 42 150 192 248 33 151 230 122 52 189 83 222 140 188 164 203 188 40 182 214 85 147 161 84 82 31 254 67 49 188 127 132 89 164 50 100 19 232 56 130 140 7 9 170 121 78 98 247 81 139 2 141 129 26 180 0 238 124 135 86 113 153 42 182 85 61 171 56 233 74 137 123 224 153 202 118 51 231 144 221 211 48 181 3 37 174 41 216 185 245 124 73 129 86 186 11 116 195 16 228 13 209 12 28 248 211 235 209 221 64 221 222 206 186 215 163 242 203 149 81 231 211 132 234 201 210 59 223 248 71 38 234 62 20 215 133 153 79 62 190 124 193 192 205 51 111 149 204 184 176 214 216 173 120 127 252 46 240 8 161 17 43 3 21 69 124 99 29 241 100 25 41 103 95 42 161 38 246 109 200 140 90 225 184 135 228 23 97 154 31 184 83 205 194 113 130 211 93 28 45 181 38 131 5 64 226 233 110 159 22 241 90 1 86 214 202 74 65 140 145 28 38 53 51 142 54 104 71 178 191 12 72 98 95 59 124 86 171 91 25 221 197 225 225 250 99 138 118 245 98 185 215 210 107 180 1 120 149 184 67 153 49 127 17 1 89 245 113 10 0 179 217 153 59 26 77 95 211 171 29 121 179 170 117 89 126 126 192 125 178 33 200 78 216 142 233 153 111 81 12 136 238 11 205 199 158 19 219 168 197 3 225 174 43 242 234 156 15 183 175 214 126 178 236 125 115 130 60 186 62 59 250 132 209 81 183 114 12 35 91 19 144 126 45 197 194 201 11 231 25 191 206 178 48 68 142 122 197 43 142 13 160 150 24 40 113 226 72 91 150 201 12 86 201 236 105 174 65 6 128 58 244 51 181 12 120 124 36 173 4 131 109 149 159 154 98 76 30 240 77 227 176 240 38 31 208 87 32 180 98 195 214 201 70 177 29 51 126 223 251 45 68 216 6 237 37 243 169 3 140 185 75 197 112 110 84 168 26 22 253 234 34 139 232 53 110 200 99 5 231 202 233 114 0 232 89 59 71 202 246 156 129 182 115 252 51 79 123 220 182 55 135 35 64 242)
#f
())
#(202
"changing tag value of digest"
#vu8(49 50 51 52 48 48)
#vu8(79 246 97 241 8 144 237 117 53 93 121 167 14 209 137 101 206 180 167 17 65 84 255 62 205 224 37 82 56 83 212 239 225 208 184 0 71 181 1 127 76 146 154 237 5 210 139 199 18 113 239 45 173 1 20 42 162 212 90 139 130 250 217 83 96 52 121 149 25 213 21 50 237 79 24 33 73 15 239 227 180 232 179 5 225 200 82 224 187 26 2 49 169 105 35 110 154 186 236 148 189 98 164 185 167 226 228 218 80 196 58 109 40 77 90 109 89 106 139 120 85 164 202 138 239 154 31 107 22 56 111 41 209 97 210 245 167 252 166 0 218 2 253 174 157 21 246 27 19 54 1 158 15 40 0 101 135 127 123 161 48 253 127 164 250 14 151 210 46 243 211 111 186 69 149 187 15 148 74 108 141 160 197 201 190 83 89 6 124 25 28 205 72 111 100 117 175 69 47 128 140 255 231 114 220 164 114 111 238 62 134 187 169 89 99 62 225 108 80 124 6 195 94 140 137 66 162 12 31 198 202 50 63 132 52 20 215 252 80 34 187 36 39 27 237 104 67 36 77 206 161 95 83 116 9 93 102 180 180 143 178 239 148 104 74 130 130 100 97 144 119 5 223 254 232 135 190 102 5 120 204 164 235 6 166 170 83 167 58 54 8 188 66 6 229 133 182 0 61 28 103 185 150 76 130 97 16 103 147 6 18 246 10 132 50 72 108 241 26 11 33 11 244 85 97 240 169 122 221 189 45 106 131 215 23 60 16 155 222 194 255 151 233 75 241 51 59 91 9 149 12 245 49 68 255 139 122 226 220 10 254 100 114 52 244 116 113 101 91 76 139 14 149 174 77 218 165 72 124 46 223 206 204 91 182 4 226 220 231 206 212 5 172 233 100 244 157 62 59 221 215 161 141 157 97 150 223 66 43 108 49 196 117 170 74 5 88 85 202 220 45 118 166 68 247 71 130 59 121 247 161 8 20 71 58 192 32 245 247 118 24 26 168 194 2 255 0 51 61 189 229 37 168 195 18 250 47 27 139 115 159 252 96 147 221 63 64 214 4 241 12 106 172 92 170 180 187 172 188 187 209 113 228 70 100 164 80 111 111 135 127 15 4 61 194 90 33 204 246 163 102 151 68 35 148 33 135 169 11 110 145 92)
#f
())
#(203
"changing tag value of digest"
#vu8(49 50 51 52 48 48)
#vu8(29 46 168 174 246 24 40 215 66 30 183 161 24 222 42 152 162 205 13 98 150 87 209 163 206 104 221 109 16 19 71 173 161 133 254 175 184 185 11 162 24 77 144 194 50 99 106 37 164 80 205 169 90 159 176 172 125 74 235 236 190 209 79 103 42 58 207 141 159 195 249 66 173 153 52 70 187 105 85 197 220 130 30 186 122 51 57 112 160 13 141 80 191 139 149 206 49 218 1 139 217 174 87 57 172 255 142 6 73 130 71 230 179 242 168 102 88 244 181 171 166 210 164 89 75 23 66 155 22 15 106 87 81 11 137 235 14 153 96 170 226 180 31 81 106 209 13 156 175 76 15 43 160 20 211 101 98 9 51 174 245 222 66 172 131 27 160 150 183 174 23 221 246 201 171 114 80 115 2 168 195 45 19 39 82 193 155 23 61 242 30 250 186 28 135 85 72 253 46 63 116 0 228 16 199 146 29 176 146 154 22 20 222 97 114 91 38 232 77 41 25 213 63 254 230 87 158 153 212 99 11 47 230 65 79 50 159 25 152 167 113 168 94 226 101 161 104 109 95 137 148 58 72 191 129 127 191 7 80 37 93 70 72 248 53 225 44 163 122 153 10 170 141 103 106 143 8 82 105 162 148 63 194 68 71 124 188 218 108 87 34 111 171 141 228 171 96 246 238 111 135 170 210 15 103 85 33 98 75 206 22 211 241 114 25 13 134 251 187 13 113 239 114 234 15 5 180 91 174 248 110 90 72 45 97 50 72 224 127 210 235 110 175 97 208 222 245 224 252 58 196 87 210 226 50 161 234 191 49 144 141 34 241 83 144 2 193 21 167 217 165 234 196 170 99 227 177 253 123 210 218 224 171 208 1 247 202 160 197 178 11 180 95 38 154 126 177 23 98 31 130 181 8 150 15 42 12 187 255 43 82 147 91 147 242 19 168 207 219 24 34 152 159 169 96 92 139 130 130 150 227 211 165 202 49 178 122 216 127 16 217 44 19 231 131 231 224 193 237 175 160 144 79 60 186 205 78 8 65 73 134 83 219 202 9 131 163 183 209 115 165 31 77 226 204 35 205 162 149 169 110 253 49 15 209 25 203 205 22 59 247 187 102 233 174 168 17 106 222 26 147 72 207 199 3 229 31 217 142 177 176 225)
#f
())
#(204
"changing tag value of digest"
#vu8(49 50 51 52 48 48)
#vu8(211 41 15 74 59 28 5 5 212 201 181 21 46 248 51 51 158 113 170 160 205 20 189 11 45 3 165 33 3 111 40 230 80 97 148 50 117 157 18 124 47 32 253 165 171 183 232 143 188 185 7 137 45 249 77 103 230 221 45 74 146 166 160 71 231 233 83 89 103 65 207 210 155 83 246 99 82 122 206 200 208 80 76 200 140 142 31 21 110 30 228 91 81 249 138 76 139 187 196 102 175 7 34 98 33 64 238 82 90 160 62 17 195 214 47 65 16 238 216 103 139 80 58 12 174 28 101 184 154 78 151 161 119 10 236 71 160 166 186 197 239 114 220 51 119 121 108 4 60 4 236 37 246 151 253 204 230 82 230 63 171 170 233 18 117 3 66 205 87 35 19 22 83 158 40 233 158 174 32 127 180 87 39 31 1 221 245 23 144 118 28 100 124 184 247 73 17 5 68 79 38 181 205 44 26 3 239 252 67 104 156 217 183 26 146 150 95 37 10 220 193 34 42 180 59 13 59 28 28 57 52 36 123 80 249 110 132 122 170 15 10 203 147 18 75 201 189 199 190 180 185 163 37 77 247 165 62 171 36 64 34 143 199 194 194 219 223 60 98 155 124 134 69 211 26 212 160 210 41 165 252 135 34 48 211 92 5 138 208 91 109 40 94 173 180 5 242 153 19 204 19 155 158 48 141 230 54 14 7 172 80 129 31 201 30 221 224 167 74 107 127 44 233 88 84 64 31 175 62 184 190 252 30 28 197 80 34 239 109 52 121 151 120 124 48 195 2 216 33 55 166 52 167 77 147 24 195 71 136 35 55 49 191 7 26 46 169 186 188 78 68 0 100 1 34 46 163 95 184 42 123 180 213 61 170 117 123 116 41 169 146 184 141 129 116 136 167 133 80 111 234 253 99 138 244 91 102 181 33 152 245 63 157 108 164 22 80 188 206 139 203 129 57 242 70 52 43 150 69 82 171 70 114 223 251 161 201 209 39 42 226 194 97 154 75 88 238 206 81 225 160 15 218 225 223 89 252 50 82 138 126 119 246 9 87 146 232 76 98 176 11 230 115 193 119 32 35 168 137 15 168 214 3 45 76 20 94 90 72 133 75 120 120 69 131 161 145 232 81 228 105 132 84 226 176 71 238 23 35 194 231 33)
#f
())
#(205
"changing tag value of digest"
#vu8(49 50 51 52 48 48)
#vu8(164 251 12 140 154 199 15 158 244 43 153 100 55 225 110 75 92 125 23 184 33 165 179 139 91 12 100 140 246 121 103 25 59 9 226 252 179 236 253 106 156 200 183 88 187 189 193 5 182 154 19 132 235 238 241 59 205 236 175 161 166 191 144 164 81 0 173 6 137 231 22 100 244 36 79 129 76 137 150 187 168 225 27 168 100 147 140 37 109 191 186 56 123 148 109 110 230 49 172 203 107 55 88 207 125 183 37 89 22 176 229 136 98 170 157 138 25 52 121 220 210 247 36 2 210 247 126 95 144 132 192 19 234 197 24 130 2 149 23 125 70 233 155 84 7 218 101 238 242 120 95 171 3 145 242 148 103 141 222 9 120 26 80 71 102 108 106 73 49 36 152 216 136 252 186 44 126 97 66 34 219 176 6 87 3 83 89 147 148 108 216 111 19 249 139 54 65 26 108 208 44 144 113 160 213 163 212 90 150 183 63 114 142 129 88 238 22 82 91 211 239 176 243 249 154 98 47 119 224 125 213 74 156 191 21 141 32 8 78 138 66 108 95 85 242 211 71 20 186 0 87 219 227 121 146 41 34 54 221 233 75 217 223 170 104 106 224 106 69 25 165 118 15 142 126 170 229 126 239 112 91 79 80 131 33 247 89 54 35 64 33 107 15 141 101 34 18 199 104 143 57 179 85 152 7 5 74 242 179 24 18 82 20 179 12 34 245 240 241 82 107 254 177 79 235 56 140 68 22 17 19 12 232 146 49 21 241 153 209 17 222 23 16 168 28 87 138 181 81 181 156 28 172 199 182 66 250 228 55 222 212 93 4 223 189 42 24 168 215 158 226 253 122 64 86 231 74 162 209 95 233 194 209 171 170 108 22 173 65 43 150 184 2 108 102 43 63 35 171 216 183 241 84 105 104 76 174 155 111 162 199 32 243 167 159 254 200 223 87 144 165 116 84 183 5 128 247 14 238 178 243 66 103 195 59 160 213 217 234 35 187 128 124 234 201 220 195 224 40 64 156 147 138 85 141 175 105 27 99 180 38 2 99 8 211 217 8 60 128 147 230 231 140 53 163 226 129 235 7 69 82 13 235 81 182 141 75 25 82 214 155 66 111 74 2 4 87 31 233 100 57 8 59 12 93 0 89 215 68 122 24 33)
#f
())
#(206
"changing tag value of digest"
#vu8(49 50 51 52 48 48)
#vu8(88 66 43 32 106 9 227 86 92 53 180 242 103 223 208 206 26 223 220 67 236 154 5 87 148 51 142 244 65 97 38 232 225 159 44 197 96 226 24 26 11 176 97 35 182 126 181 244 6 79 171 32 62 33 181 59 60 156 148 121 81 168 200 71 239 139 147 231 55 232 175 108 228 145 204 107 185 197 81 235 57 97 144 206 188 204 231 213 228 166 53 49 126 225 119 167 3 197 88 213 116 122 103 196 77 17 166 187 73 117 247 234 86 56 246 37 11 239 154 84 175 198 204 224 132 86 68 225 47 14 239 146 205 93 98 87 234 248 102 21 76 35 178 158 64 150 61 147 119 69 9 66 231 48 246 19 200 81 77 41 7 165 186 89 35 194 192 170 149 63 120 251 247 53 183 249 45 88 3 56 77 235 86 45 16 139 18 227 117 9 83 141 149 249 138 143 193 155 77 62 190 234 8 107 103 152 198 189 16 234 231 179 194 221 73 218 111 32 169 244 245 210 161 13 18 207 66 183 176 11 94 26 190 151 61 240 216 126 251 163 253 154 179 225 232 103 157 216 191 159 242 66 252 229 48 128 97 144 180 141 43 176 252 69 25 8 148 64 34 19 66 11 23 15 172 84 133 238 235 250 250 16 103 33 24 83 247 185 11 98 126 82 228 11 80 183 161 255 203 165 207 101 139 215 120 18 23 12 192 171 98 13 57 137 245 218 119 71 77 80 38 254 72 119 107 179 134 139 170 183 128 251 103 234 142 232 201 29 65 74 130 144 75 55 181 156 222 75 159 7 231 9 154 212 147 204 50 147 62 92 128 154 0 254 95 116 85 177 224 134 104 30 123 21 195 221 63 184 173 86 254 43 61 120 117 18 49 204 91 138 0 107 60 162 198 179 72 90 121 116 168 93 128 239 35 130 77 37 88 138 183 41 138 52 37 128 102 32 237 81 235 223 181 142 54 199 184 188 225 44 233 86 115 76 108 71 118 180 198 47 250 217 8 60 89 100 139 86 239 214 77 150 70 118 63 212 157 103 48 47 204 110 168 80 199 240 168 201 92 46 80 122 115 244 129 140 134 131 38 27 182 197 245 59 130 174 193 217 105 179 150 217 53 23 17 52 130 144 41 3 173 200 117 31 172 27 111 120 138 178 31 104)
#f
())
#(207
"dropping value of digest"
#vu8(49 50 51 52 48 48)
#vu8(66 239 219 34 254 82 64 193 210 134 89 54 208 249 198 209 191 25 44 159 140 244 196 120 72 118 175 117 59 69 187 97 155 36 23 202 101 217 203 36 209 209 48 44 126 213 38 44 139 120 186 166 225 103 233 106 77 97 47 236 80 187 127 179 162 93 209 0 124 160 218 76 131 69 21 21 70 37 148 243 138 16 146 164 128 160 229 162 103 173 49 42 85 107 255 83 242 254 2 249 176 17 169 124 72 200 116 141 87 52 11 199 123 161 42 29 106 193 246 58 23 81 185 69 199 193 202 85 33 214 230 106 197 36 172 109 93 138 142 2 167 104 131 132 211 149 152 3 76 118 161 87 26 101 246 242 36 106 162 71 115 160 50 53 60 207 199 100 81 95 225 242 70 111 249 91 45 73 136 155 81 31 101 24 252 221 131 132 55 119 150 139 47 200 49 122 228 136 218 248 198 97 83 218 115 57 119 65 128 68 79 148 152 100 111 149 51 231 183 222 219 135 3 120 145 148 16 1 233 36 144 206 246 135 148 144 135 241 222 159 150 224 245 252 83 171 167 180 5 74 235 88 192 181 62 51 87 225 162 1 220 88 132 112 203 147 184 236 99 30 163 89 12 30 221 6 222 8 119 37 233 209 29 71 74 115 12 53 88 48 63 155 63 51 53 39 172 220 119 219 24 104 131 232 33 219 142 232 81 117 53 197 189 23 178 11 165 2 91 146 153 98 55 199 235 87 209 94 135 200 191 213 247 5 100 107 63 145 56 242 77 133 169 85 167 141 117 121 57 69 77 71 21 48 157 49 194 103 228 242 145 77 47 78 162 42 11 140 58 206 220 136 129 45 67 65 254 10 243 138 132 211 219 204 213 180 99 38 248 221 5 213 77 49 4 73 22 91 203 51 231 1 96 15 91 101 165 67 201 109 197 14 64 53 165 235 193 19 145 219 98 255 229 109 131 89 246 69 68 237 254 8 247 66 102 5 213 210 193 63 119 192 147 48 198 164 0 218 249 170 159 64 108 58 77 37 245 137 179 124 162 152 162 189 90 83 50 14 222 92 228 175 61 102 115 113 115 132 14 135 87 5 215 122 104 53 208 174 24 150 166 150 104 60 223 194 213 122 7 34 123 207 86 213 47 170 156 124 127 62 62 122)
#f
())
#(208
"using composition for digest"
#vu8(49 50 51 52 48 48)
#vu8(111 122 118 165 149 30 203 171 103 68 64 6 61 30 132 20 28 176 66 72 122 18 212 93 38 47 216 71 49 178 193 123 232 111 247 12 180 152 131 141 39 172 154 149 120 206 102 238 237 3 74 252 95 119 1 189 201 77 122 226 35 42 221 153 89 221 129 10 211 142 242 139 73 181 184 108 204 72 244 99 92 5 165 247 154 9 21 239 237 23 202 190 228 108 123 180 240 26 115 153 94 7 111 27 96 48 5 172 131 55 198 22 233 51 255 146 93 184 138 198 26 103 77 202 129 196 173 188 156 92 123 153 140 194 213 23 36 61 163 72 33 44 211 53 198 59 120 151 119 177 193 10 59 12 55 0 78 247 2 13 7 56 223 166 193 111 79 141 134 83 249 13 22 100 104 202 91 154 252 204 25 166 46 83 185 200 168 229 170 206 193 22 153 108 37 59 128 27 218 253 102 137 72 80 216 158 10 244 168 42 241 26 168 162 251 250 158 206 253 142 145 38 94 179 209 11 116 90 1 139 123 190 117 152 104 45 212 138 169 34 29 19 92 43 129 81 230 17 224 157 238 177 69 214 0 88 63 113 88 236 95 92 183 157 98 98 134 179 233 195 113 51 157 82 238 194 154 74 179 22 133 244 54 61 107 20 218 69 44 14 28 7 116 77 200 49 152 39 146 244 23 83 97 134 216 170 32 15 145 106 177 74 70 34 150 247 132 97 177 4 175 32 20 153 104 46 243 194 233 80 13 233 22 209 142 199 188 109 68 5 160 250 84 97 78 99 126 136 71 222 48 155 234 216 117 6 1 135 107 46 15 176 251 134 181 154 162 23 106 160 123 70 229 212 233 192 111 175 111 200 174 168 115 206 129 231 141 125 186 135 230 6 78 97 194 237 56 46 148 15 166 128 70 97 243 77 234 0 48 213 24 201 185 39 218 112 67 209 62 28 165 197 210 227 152 197 193 28 145 147 13 38 46 214 4 163 244 63 25 46 68 123 238 240 198 163 206 12 72 71 4 174 44 195 111 22 200 141 160 144 248 86 184 2 233 58 196 123 157 92 138 26 214 219 162 134 236 30 45 205 252 141 183 88 240 105 13 64 160 44 192 43 85 47 76 159 195 55 148 58 43 50 247 89 50 166 184 135 151 250 235 173)
#f
())
#(209
"modify first byte of digest"
#vu8(49 50 51 52 48 48)
#vu8(144 80 12 228 205 218 189 148 195 143 196 66 142 122 77 2 79 246 152 224 91 212 108 101 78 15 142 13 86 193 129 110 152 66 18 78 48 248 220 67 7 198 121 86 117 147 57 36 143 250 182 59 200 168 155 68 13 7 29 141 213 19 207 20 79 216 189 251 217 50 154 137 89 69 172 202 101 21 210 119 84 88 105 11 170 31 145 99 107 41 5 127 50 38 84 193 93 141 119 126 110 6 88 146 210 226 136 11 35 186 116 15 50 6 176 79 43 224 222 214 59 217 121 127 49 79 109 205 18 123 211 147 34 240 140 18 9 159 123 182 85 63 113 105 97 1 36 79 52 173 33 210 70 225 37 200 233 88 16 153 136 140 181 183 27 236 249 129 62 80 12 245 77 109 7 219 120 6 149 217 44 206 131 83 187 78 141 120 221 70 81 36 80 80 142 199 218 1 146 232 150 118 117 181 114 150 14 155 188 172 234 89 88 213 109 177 200 179 172 60 229 220 54 218 110 32 12 56 129 148 165 29 199 246 237 216 108 235 156 73 7 211 21 15 147 146 41 143 242 228 5 128 119 236 158 97 225 62 187 69 171 248 235 81 19 123 202 81 168 25 62 94 21 56 148 170 59 235 127 107 88 70 218 1 172 240 147 104 88 120 69 152 117 11 28 4 148 98 91 182 175 244 175 139 8 228 25 131 120 103 126 178 48 40 44 207 87 207 61 200 35 21 16 113 145 252 209 155 105 91 195 183 40 155 60 47 3 214 79 220 246 47 6 170 46 235 235 9 88 54 89 211 238 71 63 97 56 24 9 201 202 60 38 143 199 90 206 77 105 103 95 229 13 178 184 56 25 53 189 169 155 105 247 119 251 155 38 254 238 53 174 221 57 114 94 169 58 233 69 169 64 52 120 203 112 138 64 84 227 239 212 229 126 174 129 34 180 183 99 46 9 71 69 45 95 65 127 8 222 208 186 71 155 232 224 83 137 179 125 11 142 104 117 176 212 130 12 181 234 135 77 215 254 135 44 46 3 28 162 113 127 4 189 89 46 123 140 46 221 84 178 132 207 138 113 63 19 164 108 75 122 80 30 21 69 236 222 223 170 177 121 208 138 166 175 81 53 47 21 16 166 20 88 183 29 209 143 70 221 37 81 64)
#f
())
#(210
"modify last byte of digest"
#vu8(49 50 51 52 48 48)
#vu8(153 14 19 56 187 135 97 128 146 89 79 100 168 185 36 181 137 31 200 48 11 53 68 198 163 94 86 249 213 38 87 107 168 10 216 68 121 238 39 3 100 215 165 108 230 209 173 59 171 233 118 200 88 102 151 30 161 228 165 121 225 120 196 87 162 134 44 98 212 141 56 253 110 1 152 149 180 74 153 69 236 72 18 145 225 168 180 218 14 20 172 101 109 180 147 42 213 79 49 73 59 120 136 136 26 112 178 99 177 73 79 184 66 179 215 178 139 39 130 201 89 2 227 220 65 151 156 171 112 25 51 20 55 180 209 187 48 251 193 225 211 107 242 130 251 231 211 246 56 4 171 97 186 20 243 212 36 148 1 105 78 165 38 51 52 1 13 34 172 132 102 212 116 137 22 229 70 58 62 62 163 48 222 233 115 99 187 239 81 70 242 241 176 162 151 103 250 103 76 231 36 116 79 246 123 251 88 54 153 219 236 195 193 39 149 179 213 180 227 157 99 24 212 239 208 97 11 27 249 205 220 6 254 181 135 183 198 121 120 150 133 88 23 58 181 233 108 133 24 182 148 206 197 128 108 33 68 107 154 205 151 92 222 24 125 211 2 66 175 195 234 237 123 132 23 73 177 223 131 114 195 213 112 27 107 249 174 13 129 216 203 241 154 69 8 159 183 24 67 166 184 233 51 72 47 200 98 200 11 94 179 25 62 207 255 135 15 159 181 143 95 213 210 70 54 145 25 61 215 27 19 85 58 219 197 68 134 194 69 87 41 155 72 67 106 117 6 139 170 146 32 217 83 122 82 220 194 4 41 247 53 111 29 170 197 42 96 119 118 10 237 253 130 9 57 150 121 60 213 6 179 160 141 80 202 126 153 114 218 101 141 255 248 223 136 230 53 182 253 138 213 118 9 106 210 116 206 54 49 63 102 45 212 107 82 162 213 232 34 234 222 214 127 165 31 116 196 188 122 230 110 164 77 188 60 111 59 93 222 121 44 192 23 109 120 14 52 239 215 23 74 182 74 50 73 229 48 245 247 91 14 55 35 222 202 11 20 71 208 37 106 45 54 56 180 176 208 242 106 252 24 135 196 219 189 115 207 246 118 231 188 103 251 17 79 187 247 145 233 72 58 39 205 187 111 36 23 126 190 125 141 8)
#f
())
#(211
"truncated digest"
#vu8(49 50 51 52 48 48)
#vu8(126 110 111 77 129 87 148 186 25 248 163 212 141 5 28 51 210 164 110 52 212 35 158 190 193 141 240 64 105 93 23 18 191 151 137 147 161 66 215 239 40 63 2 13 117 223 199 236 27 243 87 111 26 246 216 68 176 145 162 207 149 51 243 203 224 180 8 192 121 50 123 103 187 204 22 22 137 205 55 84 16 131 120 196 216 137 149 36 80 105 223 67 206 51 40 201 27 14 126 245 4 84 206 52 65 71 118 30 96 13 63 78 163 63 24 218 114 208 196 245 194 207 111 22 212 147 95 188 203 245 115 105 248 29 5 115 65 235 56 2 59 193 74 114 247 182 40 75 214 130 129 161 244 58 62 16 192 13 250 9 33 94 18 203 95 9 24 132 187 177 192 157 204 5 244 0 164 31 58 56 9 7 22 172 17 102 55 77 66 202 75 144 206 191 231 142 136 97 40 181 138 61 18 61 74 49 16 44 14 158 123 50 25 32 31 237 79 209 166 144 188 239 225 122 163 127 83 78 163 115 145 89 93 164 14 56 31 88 164 50 54 102 214 70 145 212 80 103 33 86 142 150 168 35 118 191 123 5 142 34 77 141 201 119 6 88 149 225 173 236 195 30 104 196 105 236 1 153 55 127 197 158 60 159 101 184 112 47 215 218 27 198 246 228 132 11 144 46 238 31 228 183 123 132 123 64 116 2 198 130 149 39 75 116 139 63 249 60 80 81 39 166 76 166 30 248 162 201 226 97 91 96 213 89 209 208 62 6 190 201 43 213 79 103 31 17 91 47 23 248 26 166 139 85 83 95 54 36 211 202 148 9 57 87 143 84 205 158 87 13 181 94 7 196 161 146 213 8 108 83 76 75 73 156 167 213 171 36 13 220 28 108 230 51 100 243 157 44 185 230 72 159 47 206 137 65 162 5 86 218 48 244 25 206 3 153 32 187 38 106 56 173 0 254 140 236 189 254 67 0 102 249 101 107 90 133 216 152 78 153 80 231 143 92 209 145 138 220 192 200 220 169 120 97 110 23 115 78 201 17 152 94 8 34 58 97 117 73 45 26 168 254 152 219 118 159 221 12 46 163 117 224 133 136 154 124 54 108 164 113 113 127 103 106 178 135 60 15 49 191 158 154 233 168 32 245 152 95 55 41 82 89)
#f
())
#(212
"truncated digest"
#vu8(49 50 51 52 48 48)
#vu8(121 224 163 228 192 76 168 23 18 139 115 241 28 66 134 230 195 154 37 182 169 121 222 234 69 240 238 10 108 192 181 185 188 103 178 6 218 151 127 98 140 141 179 178 66 180 81 252 15 170 139 163 229 34 240 236 9 119 104 1 205 120 18 146 48 225 33 210 226 201 211 2 161 255 197 72 144 82 234 225 91 169 21 39 56 209 224 250 232 121 163 36 189 224 41 84 96 130 218 151 248 143 103 188 64 227 67 20 37 185 89 157 109 9 124 69 32 89 250 196 24 57 166 232 25 78 14 83 154 90 193 169 74 244 112 143 226 157 238 77 241 226 31 0 133 1 106 236 104 243 196 252 191 126 100 183 130 8 133 190 243 94 212 205 107 93 135 117 214 145 210 85 59 97 175 181 150 238 228 153 102 107 125 188 208 67 217 40 204 216 208 190 87 84 199 59 191 54 34 96 23 187 98 178 124 223 100 188 185 0 222 217 69 46 238 68 47 192 52 18 17 245 140 241 95 182 22 76 251 208 161 135 195 172 144 192 92 70 32 57 78 243 228 185 56 65 25 26 41 156 118 62 36 245 105 90 35 13 28 3 177 237 255 0 109 119 76 244 0 210 236 47 162 212 195 151 165 174 237 147 148 105 149 83 199 16 40 57 38 122 232 55 154 61 115 17 216 215 188 194 84 119 115 232 172 187 90 127 162 169 210 114 69 151 48 79 134 91 216 255 56 233 117 175 234 209 33 226 69 111 102 155 84 164 66 253 99 18 170 163 201 191 19 32 234 172 122 159 221 216 42 191 112 194 192 210 82 191 157 116 67 47 149 149 233 209 156 235 27 137 164 22 193 193 11 198 46 3 18 21 245 121 253 80 73 246 226 239 92 52 113 127 25 44 40 243 74 237 0 191 216 49 74 218 214 146 188 242 229 175 94 104 187 243 30 210 146 57 73 223 140 40 189 119 190 111 78 204 0 245 193 206 114 93 169 252 161 43 136 79 245 168 87 109 181 139 23 79 187 17 130 34 2 168 176 21 220 109 27 60 205 213 211 6 182 77 207 78 77 241 56 228 78 141 219 38 67 38 250 53 233 105 218 215 30 174 82 22 151 161 238 2 177 1 204 247 110 121 78 178 82 172 197 71 46 160 13 131 102 212 226 173)
#f
())
#(213
"wrong hash in padding"
#vu8(49 50 51 52 48 48)
#vu8(56 143 2 222 100 126 103 188 114 154 36 29 202 87 199 95 197 93 135 101 89 214 151 88 123 48 43 221 239 24 34 45 29 15 83 169 197 246 217 69 157 69 124 47 139 34 219 135 32 120 250 62 231 52 7 190 155 230 236 21 120 95 151 33 64 13 65 79 190 144 138 206 209 175 148 83 9 46 36 26 65 217 80 105 68 238 76 127 11 167 156 163 208 81 149 64 140 190 209 49 166 207 78 226 129 103 149 154 211 92 255 202 239 43 136 144 50 19 167 169 247 39 2 120 207 236 201 198 16 119 81 126 59 124 159 183 43 238 87 43 234 40 23 232 192 167 116 4 11 94 181 8 191 178 128 227 187 200 120 236 175 140 172 185 31 190 194 45 19 10 26 18 59 141 214 69 28 55 68 222 119 157 221 252 117 22 228 131 252 1 85 79 22 173 169 144 1 110 214 228 238 129 71 6 136 176 217 27 54 25 154 142 126 11 138 163 243 225 33 97 245 60 168 89 178 172 207 6 103 161 163 6 188 16 207 158 102 229 86 36 16 193 131 197 50 43 16 36 240 234 199 207 164 165 230 51 255 153 65 45 118 157 82 160 220 44 88 91 123 106 87 6 199 53 27 125 4 178 109 123 144 97 212 69 90 151 248 155 8 36 2 60 234 191 222 152 55 215 67 160 106 54 236 151 78 208 193 166 38 252 162 12 149 229 221 30 26 58 89 225 86 50 188 107 85 108 131 148 204 244 115 60 133 169 185 0 140 141 206 248 150 147 202 52 248 205 50 132 120 22 235 117 243 3 201 107 98 126 204 136 1 195 162 91 97 41 131 240 216 176 152 192 131 51 22 180 39 245 223 214 104 52 175 189 146 34 17 12 49 232 28 97 235 46 170 207 163 155 80 130 210 32 123 84 126 204 194 92 3 168 37 100 140 222 135 90 9 160 61 34 5 8 11 67 82 197 205 107 71 195 42 82 87 249 183 123 107 77 37 182 6 248 126 53 60 160 150 234 91 99 251 10 229 229 30 10 222 32 26 196 69 45 60 196 87 164 155 233 170 201 6 142 88 76 169 240 86 253 89 8 171 166 38 181 251 18 250 209 101 253 177 104 122 53 138 1 10 223 66 2 13 106 161 113 82 103 106 17 166 160 96 223)
#f
())
#(214
"wrong hash in padding"
#vu8(49 50 51 52 48 48)
#vu8(54 92 90 67 44 211 238 193 90 169 61 247 105 23 197 119 169 71 197 68 47 250 152 55 60 112 241 145 153 222 169 111 253 143 170 232 35 63 70 150 60 167 0 82 52 129 35 211 148 121 111 89 97 2 80 110 78 9 230 113 116 147 174 178 87 217 221 164 19 22 175 192 73 150 120 173 17 223 145 16 74 255 252 30 32 190 239 217 79 13 87 80 15 172 45 215 183 27 60 160 54 111 49 135 69 47 60 32 43 212 68 24 98 234 79 247 21 193 42 245 59 104 240 16 1 229 5 78 248 81 172 238 241 56 176 148 70 26 187 119 150 165 220 132 191 83 247 196 231 0 110 255 189 159 249 30 30 220 73 142 134 126 117 72 84 197 146 19 192 17 106 141 222 158 166 148 33 7 49 235 54 108 83 114 156 178 182 169 217 3 139 21 59 162 135 155 13 229 181 201 8 139 121 168 74 149 82 243 246 242 2 18 19 1 13 201 21 176 65 113 62 185 53 15 122 24 88 227 56 254 231 6 60 238 67 170 15 25 95 199 6 57 71 155 95 169 230 83 158 105 3 60 141 63 18 172 215 142 255 115 195 172 17 0 37 246 247 199 220 230 212 114 162 64 245 230 174 162 190 236 155 125 139 196 19 226 125 244 160 204 91 229 231 62 136 122 194 101 251 37 141 223 92 148 236 144 192 164 144 156 115 165 139 253 75 238 188 253 159 35 96 46 225 15 120 168 168 179 149 170 23 204 255 94 115 122 13 226 160 97 57 67 85 177 188 94 60 104 142 208 107 166 94 139 87 150 122 66 154 44 53 42 36 55 164 72 253 191 143 229 46 193 218 9 52 184 234 162 183 194 48 229 7 52 30 250 38 37 188 78 1 92 33 167 249 170 78 5 11 38 211 170 198 228 116 172 127 45 205 112 153 132 100 55 0 160 82 27 13 132 12 249 60 41 162 118 193 46 111 243 41 120 217 42 219 243 102 144 210 254 139 204 158 18 164 47 66 194 97 25 241 244 50 167 48 75 19 80 195 213 132 160 75 20 204 111 49 228 86 111 114 120 110 193 226 77 90 225 252 184 182 110 215 216 226 134 25 160 44 187 143 33 123 29 138 58 178 147 138 160 185 46 91 60 216 211 208 251 251 119 245 197)
#f
())
#(215
"wrong hash in signature"
#vu8(49 50 51 52 48 48)
#vu8(100 215 151 201 164 128 160 175 41 188 29 15 171 135 127 235 3 30 18 210 17 98 29 23 128 240 230 199 209 225 33 255 247 132 144 218 203 69 12 132 202 136 97 36 51 97 96 179 129 196 158 41 133 249 1 72 184 96 21 227 42 219 93 9 15 58 91 9 227 204 70 253 222 176 144 95 146 195 239 185 78 46 232 135 209 96 0 141 90 98 33 166 55 65 31 254 205 114 93 248 233 43 170 168 36 159 7 196 82 67 151 80 196 11 10 251 136 101 69 133 189 40 123 175 228 166 29 228 80 151 33 235 75 215 29 153 47 98 209 244 158 249 102 149 193 85 5 81 56 254 249 6 207 40 70 162 171 248 197 29 112 163 51 32 107 215 161 158 200 176 201 234 24 42 123 77 118 195 60 33 25 106 167 45 21 138 12 167 251 61 212 74 57 228 25 31 164 125 6 30 47 226 131 219 185 141 187 9 20 133 154 115 213 252 25 156 41 112 128 247 26 28 145 84 119 48 178 25 163 101 100 107 95 219 188 11 57 126 210 180 238 179 5 94 167 172 56 250 46 39 172 35 110 240 85 150 84 86 188 46 163 150 172 193 234 40 2 227 103 237 27 70 93 71 6 255 126 30 216 16 98 2 71 55 138 188 246 84 92 251 55 147 166 149 160 171 175 146 67 51 178 145 166 186 142 23 20 219 73 134 165 180 133 247 160 97 139 115 27 154 212 176 59 61 7 234 63 141 123 233 1 20 249 214 98 17 255 139 48 254 187 45 239 36 94 106 86 17 8 38 76 35 127 143 200 195 94 82 178 9 83 185 196 158 98 1 70 190 171 156 57 18 249 160 18 204 93 66 30 248 186 95 219 190 195 161 66 9 140 233 134 28 103 80 73 140 247 173 5 217 213 229 203 85 122 43 195 134 150 2 116 217 208 189 9 20 120 187 226 12 8 109 51 33 207 68 200 248 70 103 85 220 236 224 7 138 10 94 200 61 32 109 12 63 112 116 79 35 75 191 224 19 12 63 107 180 85 241 117 160 56 219 25 237 51 99 6 186 119 209 196 100 106 87 141 34 159 201 74 210 219 171 218 247 115 196 148 82 191 160 106 208 27 143 200 170 107 99 164 212 216 20 76 50 112 1 139 188 18 47 135 194)
#f
())
#(216
"wrong hash in signature"
#vu8(49 50 51 52 48 48)
#vu8(38 134 78 84 216 79 41 181 51 103 172 112 115 223 132 206 93 136 92 123 103 50 14 9 243 189 58 132 104 222 114 248 238 33 37 63 17 87 231 70 128 25 10 20 200 149 137 117 53 224 77 136 97 167 70 0 57 151 14 16 189 31 28 127 70 144 162 183 226 66 47 51 196 235 44 24 251 239 175 114 168 91 85 42 38 218 194 123 207 94 102 170 151 164 118 58 26 50 168 104 27 38 39 64 156 138 113 196 166 227 91 93 132 94 53 163 239 103 185 118 239 2 148 15 224 164 228 121 83 90 11 98 57 228 209 238 199 39 228 162 20 204 123 215 243 2 155 60 54 172 161 145 206 91 236 64 240 146 124 241 106 56 84 42 70 69 55 100 186 148 236 240 101 25 70 151 141 243 57 111 107 241 45 236 35 195 243 60 120 55 109 247 112 132 47 40 175 248 215 82 242 83 8 194 236 199 78 88 139 241 108 239 50 76 192 249 170 21 107 15 82 201 59 21 144 5 111 63 94 1 36 140 88 159 85 228 21 236 56 123 222 231 47 150 121 11 28 223 1 240 122 72 245 127 5 141 30 174 151 48 223 255 224 94 239 200 136 41 82 248 138 74 25 62 118 234 121 192 58 50 148 30 5 31 117 12 73 179 158 95 66 8 54 100 248 229 106 26 9 133 78 199 241 25 49 249 181 155 136 13 209 158 198 152 228 253 41 155 21 84 39 226 9 97 75 173 17 95 39 120 18 177 223 203 232 19 117 52 45 131 54 9 96 18 255 109 91 129 156 10 61 53 146 255 49 153 76 46 103 52 193 31 227 170 151 103 242 224 124 166 30 95 204 27 56 251 2 132 188 204 184 14 180 118 58 170 234 120 174 51 72 61 10 167 62 81 9 24 41 19 52 126 222 52 236 234 76 209 87 30 251 168 8 108 247 164 83 42 133 200 114 226 127 57 55 95 115 106 237 140 213 99 72 174 242 9 84 78 251 92 67 59 1 59 145 42 113 226 94 131 43 247 216 246 87 184 136 80 98 223 189 240 146 8 94 52 235 169 182 12 212 82 58 17 132 5 152 94 133 55 11 165 151 53 202 60 136 5 97 97 88 238 233 178 67 31 177 53 224 97 210 201 183 175 111 26 30 16 10 119 218 121)
#f
())
#(217
"wrong hash in signature"
#vu8(49 50 51 52 48 48)
#vu8(5 239 187 160 59 144 189 167 186 40 12 106 162 188 138 246 85 200 132 222 36 1 201 255 157 213 158 13 130 200 80 45 202 61 144 135 150 148 105 46 162 179 231 124 109 211 251 14 31 24 7 119 178 55 228 98 186 224 168 179 92 194 20 151 195 104 24 161 220 137 223 166 75 202 137 203 7 186 188 16 221 185 133 56 174 225 10 78 89 180 4 12 54 108 132 19 50 110 121 188 1 92 162 235 224 165 62 230 164 196 159 93 154 135 186 197 80 228 182 168 23 63 180 145 136 174 239 210 132 87 181 148 66 12 242 215 123 188 4 79 111 79 106 125 123 165 45 101 127 93 198 182 49 173 145 75 176 91 203 242 144 18 147 229 235 90 23 168 141 173 35 38 181 8 98 75 105 139 49 209 250 8 208 10 0 29 184 203 164 169 244 43 235 176 234 186 7 232 114 53 168 131 188 113 149 19 170 33 122 54 238 1 104 50 177 44 196 202 13 98 133 152 33 45 93 164 22 175 99 66 133 93 167 215 123 161 83 229 67 94 215 234 93 4 178 69 157 104 199 33 173 235 168 192 113 233 121 191 137 192 74 60 130 25 214 126 181 20 167 155 58 47 105 38 101 12 85 231 36 182 47 128 11 79 144 96 17 4 121 68 46 79 139 130 234 213 99 48 226 55 76 222 139 51 85 82 220 253 195 208 249 64 24 97 146 250 159 166 218 168 21 107 30 85 0 88 150 254 116 163 183 22 69 32 130 62 123 127 33 97 20 33 194 129 36 43 55 218 13 237 71 105 3 244 180 75 232 234 53 181 148 162 217 124 176 201 138 125 42 80 18 59 230 6 195 227 193 27 73 132 197 165 94 208 27 24 72 252 84 184 63 104 28 238 196 72 219 196 211 93 21 195 137 40 59 38 222 102 199 19 240 90 13 49 153 58 211 230 225 179 170 255 6 182 240 70 171 7 93 147 168 202 117 195 229 85 143 143 42 68 92 241 13 94 184 19 189 111 39 84 197 2 201 62 129 185 4 216 69 251 85 201 224 129 12 167 37 154 1 40 64 203 12 133 5 107 10 126 20 30 141 58 127 165 132 157 165 14 21 124 70 22 76 156 2 255 192 153 244 44 255 183 19 104 240 172 61 172 119 178 206 182)
#f
())
#(218
"wrong hash in signature"
#vu8(49 50 51 52 48 48)
#vu8(24 42 60 48 9 200 139 116 66 32 187 71 64 242 231 163 251 175 249 246 145 173 39 221 87 46 243 103 140 144 143 194 40 151 172 202 219 214 144 12 139 117 75 71 165 246 128 120 67 3 151 137 113 253 156 204 144 54 74 25 161 62 43 104 28 152 11 215 27 225 180 82 128 213 127 235 195 61 164 209 203 98 1 189 178 247 239 182 27 44 72 222 228 179 149 115 142 104 20 251 34 141 65 32 58 108 185 156 91 106 255 214 225 26 3 39 251 10 146 13 185 3 25 176 184 87 131 153 237 116 97 240 87 90 205 37 21 113 83 191 72 55 147 240 71 208 44 192 36 102 32 31 191 99 131 71 139 5 230 28 73 104 59 220 97 10 211 176 231 126 149 217 173 201 145 231 33 79 38 219 94 104 93 12 167 204 221 62 167 124 80 105 8 93 66 22 51 193 215 184 148 200 37 61 160 207 89 5 187 22 228 18 255 146 197 221 145 191 10 136 233 235 253 52 203 101 178 240 52 126 79 33 72 116 30 143 102 12 57 227 161 86 112 5 72 168 245 232 71 144 48 17 175 28 24 33 252 91 65 57 191 48 100 73 215 127 10 203 90 135 3 104 112 99 161 107 190 211 253 225 197 234 5 187 140 124 207 146 1 244 70 52 252 240 138 248 133 64 160 5 245 144 235 95 145 66 26 20 217 100 49 190 18 70 85 220 61 193 27 215 220 153 34 195 86 153 200 181 201 36 75 211 40 109 194 81 77 243 176 52 201 115 219 80 164 40 158 73 235 23 155 116 36 236 175 246 195 221 183 195 247 3 142 99 71 74 39 10 221 226 213 163 71 230 19 141 217 241 197 222 183 181 189 58 12 90 55 32 217 96 49 76 111 110 71 177 80 140 56 251 171 182 52 102 224 2 145 87 195 79 59 103 81 126 144 68 181 192 196 71 60 11 136 168 69 227 20 164 176 25 62 0 87 212 96 56 76 98 207 189 126 197 186 114 81 20 99 91 175 40 253 68 243 90 176 249 2 61 89 1 156 43 211 191 72 169 216 178 35 147 30 21 135 5 118 51 116 149 144 193 156 142 150 23 92 131 132 195 165 37 211 85 117 66 157 155 78 137 208 21 133 234 21 202 234 69 106 109 148 121 100 223)
#f
())
#(219
"message not hashed"
#vu8(49 50 51 52 48 48)
#vu8(76 98 4 23 195 170 213 141 150 111 118 39 84 182 78 34 195 227 125 157 80 79 75 150 237 212 73 68 18 9 24 120 46 96 76 123 198 45 177 197 246 159 248 98 229 27 168 118 245 98 222 66 183 83 118 36 146 134 2 10 20 18 15 181 169 198 34 48 99 249 146 238 230 186 219 35 11 178 240 227 173 138 154 89 220 114 71 226 17 246 170 151 81 80 80 213 204 184 20 47 37 1 185 68 11 154 120 44 216 233 211 146 187 88 74 90 39 236 218 9 242 239 29 195 235 182 224 28 196 51 203 89 247 136 255 130 58 190 211 132 83 147 129 44 132 97 103 34 157 146 147 78 15 116 209 71 28 226 112 245 40 97 6 178 84 34 163 88 113 90 123 85 143 199 145 194 110 128 60 252 229 113 22 54 38 52 181 17 206 191 247 68 104 242 189 48 83 47 108 183 138 53 95 69 75 111 58 35 226 8 21 8 80 250 95 111 72 125 167 113 251 38 29 132 242 199 239 15 102 159 147 56 225 141 146 121 125 61 189 138 255 15 125 90 143 150 195 228 110 61 119 68 177 14 157 62 204 249 58 116 237 91 33 188 28 28 126 134 108 106 194 181 179 218 247 100 164 191 59 212 230 46 96 175 132 178 164 124 110 194 178 184 215 173 46 30 251 141 217 78 185 134 170 46 188 38 223 156 69 200 69 229 192 152 1 41 88 167 245 17 131 170 243 70 32 136 242 214 38 219 70 142 26 2 163 224 160 235 45 110 12 77 190 143 120 40 162 57 31 14 247 135 46 46 235 101 60 152 103 11 208 217 51 75 17 93 247 179 40 150 206 195 167 251 181 51 25 66 149 31 217 93 77 26 75 210 148 109 115 228 43 245 159 44 107 132 120 118 118 26 222 159 168 102 202 60 73 75 128 93 102 24 196 231 129 81 41 70 95 155 145 220 92 200 29 39 105 7 40 244 128 88 204 119 134 187 247 252 17 133 91 26 12 11 22 155 199 234 240 35 226 173 147 147 218 24 213 67 130 156 180 26 167 245 214 147 230 101 87 109 25 21 181 252 76 120 199 202 53 212 52 108 87 240 24 172 133 216 236 88 200 99 122 199 24 154 131 84 13 50 112 106 45 248 240 233 181 169 230 78 54 239)
#f
())
#(220
"message not hashed"
#vu8(49 50 51 52 48 48)
#vu8(145 65 124 235 144 1 170 72 100 28 146 209 238 179 223 116 89 249 30 185 62 55 159 62 173 203 27 51 22 76 2 246 25 207 93 98 109 156 197 148 112 26 135 213 195 213 31 139 206 111 0 218 134 160 123 205 24 83 152 77 239 42 196 47 226 115 195 173 77 99 197 0 100 197 50 201 205 189 177 205 80 112 53 190 84 245 224 227 68 6 103 109 31 125 154 94 200 209 26 190 149 82 221 222 16 62 49 162 250 35 216 249 0 147 114 116 139 157 72 91 199 126 23 191 215 3 137 211 199 66 49 179 101 14 198 254 116 172 200 190 102 81 224 25 175 47 41 155 110 45 129 131 207 156 226 1 45 26 114 46 58 169 31 155 138 155 204 5 236 82 83 121 35 199 145 189 67 178 199 239 52 86 114 9 165 77 32 10 220 188 97 252 77 50 73 138 188 88 173 217 183 88 66 245 239 36 65 23 166 88 21 147 81 180 75 41 184 181 120 84 229 228 5 34 40 223 170 219 146 90 211 211 60 209 85 154 193 19 70 117 54 156 23 116 135 68 114 139 113 216 35 248 213 95 216 245 124 70 23 226 42 148 38 34 222 185 38 228 10 233 6 153 217 141 117 73 65 179 77 39 113 104 14 81 39 131 20 179 130 170 73 106 189 1 210 67 142 124 208 71 40 11 226 150 0 223 5 110 35 204 46 38 103 205 239 243 36 100 168 168 52 136 17 128 132 123 40 217 73 189 169 249 215 223 117 255 67 101 224 9 241 20 213 191 70 178 247 246 125 248 93 0 6 143 52 127 32 28 248 104 33 185 190 205 117 44 79 240 239 36 171 55 37 193 115 238 226 217 151 27 197 251 132 85 159 151 49 217 241 10 232 74 233 80 226 13 82 221 243 51 136 24 178 221 216 198 135 224 81 234 141 33 201 53 213 141 235 222 46 115 37 121 103 86 202 76 131 167 39 30 217 27 20 4 6 70 207 126 111 192 17 116 135 75 177 20 79 133 6 181 187 70 78 247 28 247 72 222 44 144 105 64 152 54 217 69 142 143 14 129 5 225 158 196 169 61 99 120 32 87 222 153 79 51 120 80 205 96 94 7 176 34 167 61 62 46 20 135 238 220 53 178 171 197 71 241 192 153 174 13 177 40)
#f
())
#(221
"using PKCS#1 encryption padding: 0002ff...00<asn wrapped hash>"
#vu8(49 50 51 52 48 48)
#vu8(134 235 184 108 200 152 208 75 48 45 157 173 81 14 159 197 224 1 141 104 94 179 52 201 250 177 22 174 145 135 185 89 59 94 43 150 144 201 243 44 184 33 155 191 195 49 122 156 41 6 168 17 65 92 127 243 57 83 27 85 64 49 36 141 102 142 41 206 89 228 246 65 203 27 253 195 107 241 43 228 62 134 220 145 239 9 91 24 232 246 13 103 27 32 240 111 27 0 33 228 230 231 35 171 205 85 237 77 222 245 99 248 55 216 218 106 248 208 120 191 34 73 45 75 0 176 164 235 238 45 202 221 201 24 197 133 222 218 191 198 154 154 152 213 83 5 110 55 242 136 143 35 87 215 225 41 45 69 19 219 60 248 9 10 243 11 44 34 5 127 252 238 254 152 185 67 127 46 199 81 248 0 63 1 42 164 100 123 52 191 35 11 167 232 18 141 213 181 98 141 239 196 58 64 217 16 126 79 54 164 253 190 49 157 109 210 16 240 252 140 96 141 183 153 86 83 125 234 206 20 131 255 41 135 50 120 57 254 222 119 177 172 164 174 11 222 231 55 110 1 223 47 126 198 238 71 53 233 229 115 96 109 207 70 3 130 38 39 49 132 184 221 23 82 211 199 250 152 156 50 0 15 171 152 18 126 206 2 45 245 56 222 49 198 94 213 181 157 148 191 175 19 19 97 135 20 199 217 44 8 19 122 53 179 114 77 174 68 90 8 141 32 153 32 165 134 125 206 46 103 51 141 175 50 157 149 22 188 127 188 10 136 63 169 106 152 134 162 208 197 164 103 26 17 137 1 62 7 171 213 220 209 20 146 158 92 62 122 164 45 21 22 150 164 103 245 142 77 161 174 126 214 35 250 49 30 177 111 103 195 250 193 75 201 67 31 102 20 107 61 1 92 175 70 32 95 46 112 254 93 146 44 24 190 31 101 94 67 166 246 96 117 46 56 132 129 255 47 128 153 192 119 171 127 129 110 167 223 225 143 159 226 5 106 249 74 93 175 192 86 82 134 230 252 42 127 222 13 11 234 176 103 129 192 11 34 83 163 14 186 52 7 226 182 70 154 163 234 137 110 112 120 12 250 0 175 175 115 244 65 225 183 38 193 204 91 233 252 105 192 230 39 89 137 51 121 195 159 129 190 100 230)
#f
())
#(222
"using PKCS#1 encryption padding: 0002ff...00<hash>"
#vu8(49 50 51 52 48 48)
#vu8(18 5 53 36 252 30 171 221 158 177 243 153 18 153 156 184 131 57 177 47 83 235 40 23 229 10 202 175 110 192 186 155 40 165 84 228 3 127 223 223 175 182 83 63 223 242 123 224 231 77 187 213 62 149 182 103 70 206 34 253 92 21 93 79 127 104 152 179 216 43 58 145 124 48 15 169 90 52 113 129 155 229 17 153 253 226 82 236 119 196 116 125 127 234 230 97 8 25 127 127 239 184 245 162 167 139 185 246 173 175 146 120 57 239 105 108 181 213 176 82 76 211 72 35 19 130 120 33 213 101 55 161 175 124 114 186 75 104 70 61 3 59 90 249 196 170 157 188 124 105 0 138 25 121 62 96 5 50 89 56 89 71 236 54 114 120 7 4 167 114 172 75 36 129 234 82 82 245 34 157 138 172 80 20 60 112 73 210 174 158 144 160 32 95 29 164 102 251 141 63 206 65 17 190 248 30 133 107 139 54 42 169 136 38 20 47 152 181 208 143 211 107 218 43 61 43 121 242 119 190 185 66 166 242 141 162 109 181 9 16 100 107 188 120 208 106 13 176 21 168 55 27 199 93 41 167 91 223 145 191 41 173 194 170 110 15 37 80 147 171 30 39 186 49 169 101 159 167 180 245 253 109 153 127 35 21 14 62 202 126 10 190 210 250 160 217 6 155 55 169 95 72 3 251 215 109 211 244 228 166 87 184 215 250 142 28 252 28 15 23 52 186 241 85 159 73 23 61 161 59 119 131 253 208 223 65 249 231 59 209 155 214 169 63 58 67 41 31 170 116 14 149 247 69 44 83 198 237 5 180 193 210 87 41 132 45 70 30 41 7 170 205 106 94 42 168 77 146 38 216 9 212 179 186 232 248 114 159 160 139 188 147 225 0 114 215 146 5 21 71 155 175 105 26 52 178 186 127 113 236 109 59 58 22 48 180 222 116 134 91 156 122 212 241 195 211 215 50 5 202 166 123 24 20 155 135 249 19 112 31 233 198 251 150 68 191 201 239 190 113 82 35 243 208 247 95 95 190 27 105 136 193 214 35 205 76 62 42 250 65 156 201 80 221 72 176 157 200 164 4 129 99 248 153 22 91 153 14 234 36 233 177 180 59 148 111 88 0 198 20 227 124 129 58 169 73 14 61 116 251 170 53)
#f
())
#(223
"using PKCS#1 encryption padding: 0002ff...00<message>"
#vu8(49 50 51 52 48 48)
#vu8(61 90 151 219 154 121 225 46 55 82 177 218 100 47 37 174 209 147 217 92 154 52 126 4 78 184 36 133 12 212 236 35 87 229 228 93 199 67 124 227 40 210 37 217 185 8 147 209 112 39 93 223 79 64 69 229 126 219 204 89 104 131 254 113 88 123 101 233 1 46 199 20 143 116 247 33 158 175 110 216 210 179 171 230 150 126 63 177 184 165 136 207 149 187 191 184 148 151 198 82 16 179 77 182 83 37 138 52 176 76 72 54 95 116 133 246 134 231 195 149 14 90 236 212 23 134 225 140 211 22 206 115 96 156 74 7 218 112 192 34 121 136 54 170 179 159 86 45 57 150 117 134 85 77 42 83 99 107 142 172 83 36 150 184 131 218 44 171 200 179 75 121 106 54 6 229 111 124 171 102 71 108 118 17 45 124 150 175 126 43 114 253 64 11 51 1 14 220 212 173 118 53 182 205 203 12 90 236 189 239 157 234 194 223 31 180 22 117 11 6 190 61 111 59 184 143 252 51 27 25 84 12 177 1 205 107 39 202 254 132 130 183 27 129 4 98 157 95 141 47 81 55 48 202 93 15 1 233 136 13 216 101 76 101 250 121 202 0 119 132 218 237 37 247 229 27 218 218 191 100 205 224 83 167 84 156 76 127 100 211 192 201 254 245 10 30 180 1 186 114 211 58 204 193 46 74 60 153 200 176 239 138 96 101 151 233 14 219 54 22 111 163 142 237 81 248 153 144 200 181 45 202 115 202 247 123 250 203 117 208 94 165 34 134 236 39 240 1 15 72 52 210 23 71 168 51 97 30 63 197 186 146 116 225 3 200 172 195 108 110 180 27 169 203 168 60 73 60 69 3 237 129 212 198 91 0 232 160 24 133 8 250 53 20 29 101 148 218 43 44 100 219 171 92 22 169 181 192 109 22 224 48 161 29 221 149 138 31 217 52 142 164 188 67 137 226 44 216 41 4 161 149 172 4 64 42 186 70 224 58 140 201 78 177 107 150 34 49 58 106 37 143 111 53 239 117 31 164 76 232 220 41 97 201 74 82 88 0 254 107 252 189 193 167 187 161 123 62 188 229 75 87 196 64 145 59 138 195 103 179 195 247 138 208 102 239 45 168 107 183 89 88 52 12 250 27 93 56 181 106 184 155)
#f
())
#(224
"using PKCS#1 encryption padding: 0002ff...00"
#vu8(49 50 51 52 48 48)
#vu8(88 101 106 79 207 42 103 220 129 65 192 10 10 49 22 39 190 84 143 128 79 82 35 221 189 178 35 254 33 59 17 27 14 103 212 177 40 34 94 17 77 131 107 237 42 221 205 212 89 56 85 159 184 192 58 136 76 108 250 42 133 241 98 240 220 192 36 46 81 169 23 218 252 247 98 72 208 196 195 30 187 223 219 137 232 86 193 137 171 3 12 116 205 152 76 89 229 199 134 171 191 13 154 60 63 198 56 216 220 170 52 56 221 153 101 130 170 84 232 220 82 171 11 75 181 34 151 52 183 40 32 56 172 8 157 189 218 237 177 2 42 162 124 125 58 237 79 172 170 209 172 43 222 181 236 249 82 205 122 167 255 246 30 19 197 4 29 220 142 160 81 110 221 171 238 161 172 83 83 55 41 118 232 11 129 220 180 118 159 7 186 200 78 135 139 203 113 244 44 138 65 79 78 26 7 189 208 193 240 66 128 124 245 33 221 27 200 171 166 5 94 137 199 108 77 236 62 65 132 93 85 107 61 11 145 148 163 148 65 234 112 206 212 15 72 150 251 205 5 115 88 224 78 33 121 234 132 68 20 4 156 87 124 200 11 198 57 90 253 196 255 118 52 195 26 20 241 97 173 50 2 122 3 170 191 13 141 60 160 138 136 45 243 99 187 76 171 239 108 249 199 110 33 49 20 235 36 46 163 49 208 91 161 74 73 237 234 115 171 49 55 171 52 73 201 78 55 84 173 171 40 153 73 196 211 70 151 142 187 42 240 70 200 173 122 154 168 123 229 222 248 97 117 83 161 208 98 208 255 33 190 179 197 19 5 145 29 236 51 240 212 236 226 249 133 223 232 220 169 185 129 99 212 243 210 196 51 102 80 99 147 116 235 30 116 128 212 179 15 149 91 227 209 169 12 248 42 165 254 254 222 8 190 129 94 35 15 119 159 199 84 180 90 94 100 252 11 29 7 102 92 198 250 75 92 131 24 23 69 240 239 201 127 31 5 84 216 142 74 205 198 5 224 101 202 23 51 235 41 96 56 102 113 48 160 251 66 75 241 51 73 137 124 243 222 157 22 49 76 161 228 62 15 100 26 213 5 158 134 135 125 202 116 109 129 79 185 163 232 180 211 169 243 48 149 75 91 239 172 122 167 0)
#f
())
#(225
"invalid PKCS#1 signature padding: 0001ff...ee00"
#vu8(49 50 51 52 48 48)
#vu8(120 251 230 133 25 177 6 71 94 148 7 240 236 131 101 42 158 231 155 198 12 62 221 172 195 65 152 96 25 2 55 174 148 123 33 204 191 222 224 77 176 158 126 228 56 63 43 91 16 25 174 216 199 206 20 212 131 45 72 21 51 22 73 159 33 244 52 139 184 113 38 237 229 248 151 110 13 49 167 18 32 12 168 92 196 132 177 20 189 183 195 41 144 224 103 161 94 206 100 125 99 116 5 206 140 202 32 219 26 11 89 24 168 183 229 28 41 201 227 35 88 44 120 222 86 93 225 43 130 139 173 55 138 62 19 200 93 119 113 121 15 107 216 145 134 201 145 86 13 141 131 196 5 194 18 202 25 93 118 93 106 142 62 221 188 119 71 26 7 122 180 226 57 247 90 20 121 25 216 23 203 141 167 143 195 92 144 118 36 144 10 239 145 109 192 168 28 57 78 159 129 36 16 58 80 150 184 215 55 227 149 193 213 168 234 112 247 159 65 110 110 114 119 194 140 4 30 2 199 189 75 27 75 7 132 28 243 87 1 218 113 132 171 248 148 52 48 251 68 62 129 247 132 79 47 133 251 159 220 52 150 32 200 188 255 77 124 141 27 240 243 142 75 36 118 194 122 253 116 151 126 191 238 179 1 245 142 105 130 255 120 177 68 35 118 251 90 96 203 242 109 157 245 157 238 148 10 228 47 194 7 28 235 76 167 138 238 212 66 20 84 106 173 214 179 71 116 161 228 135 192 179 131 208 45 69 139 183 215 107 121 146 68 237 27 205 230 133 216 217 19 167 133 128 49 102 68 10 145 71 175 71 222 5 0 166 91 129 102 86 143 90 29 155 208 184 165 168 5 237 60 102 93 217 93 107 130 65 171 156 129 191 220 12 161 218 6 136 57 196 107 171 225 179 68 204 242 169 184 171 227 212 66 26 183 222 186 208 190 1 2 204 186 187 237 67 138 56 79 95 209 49 210 227 184 93 58 115 63 154 98 94 85 190 121 1 12 68 211 134 162 223 109 125 150 232 150 178 219 13 6 227 254 156 46 202 153 112 195 171 231 158 29 65 61 178 148 81 94 181 78 71 159 179 199 24 205 239 123 71 198 168 146 135 228 143 36 97 119 32 123 142 117 183 95 71 162 163 72 6 43 90)
#f
())
#(226
"PKCS#1 padding too short: 000001ff..."
#vu8(49 50 51 52 48 48)
#vu8(143 173 66 128 69 45 161 157 124 185 193 235 201 9 135 51 182 211 55 238 141 171 14 233 19 22 61 134 50 98 10 21 231 242 122 169 174 21 57 144 121 22 153 62 12 252 182 87 119 71 253 245 147 72 151 204 179 106 222 27 73 82 134 252 102 215 130 38 223 93 142 188 241 85 45 194 215 206 73 84 68 36 27 127 78 83 240 229 53 114 223 101 54 120 202 90 16 40 87 148 63 253 68 106 226 97 133 0 38 178 204 248 104 157 247 167 47 63 176 36 72 53 39 37 27 168 76 44 51 77 3 149 244 115 101 191 171 110 189 224 121 26 140 156 62 157 236 2 142 45 90 245 133 37 164 49 129 249 28 105 165 172 199 139 54 114 182 126 9 128 60 99 67 206 243 170 8 105 97 58 116 186 89 206 79 25 103 172 45 135 229 98 39 174 159 126 36 207 78 37 179 42 130 117 59 213 15 222 132 111 189 54 24 166 152 95 176 83 38 185 30 96 3 230 20 70 107 222 71 19 118 101 81 254 104 56 179 120 147 2 236 8 78 7 0 195 126 156 98 238 152 251 247 17 211 27 123 17 115 231 122 16 77 238 33 179 147 223 179 253 46 75 165 6 219 29 156 45 153 189 160 195 116 77 4 225 26 19 116 204 228 14 27 176 193 195 228 225 104 12 17 153 197 233 167 17 25 204 76 180 228 215 72 44 54 95 106 75 149 14 14 240 96 146 179 48 233 75 205 49 14 233 193 45 192 140 98 172 17 102 71 65 1 148 65 101 210 108 122 154 170 147 40 147 89 20 242 166 215 144 144 167 148 101 198 146 57 238 241 74 223 102 163 33 23 112 149 40 254 200 146 97 156 38 245 158 35 75 87 85 83 13 28 16 197 153 115 180 10 85 194 137 184 95 94 95 52 197 225 71 175 68 200 68 96 226 238 131 79 10 71 152 244 154 166 26 22 20 140 138 54 250 213 252 37 91 208 38 33 181 245 18 18 144 141 115 8 155 16 147 109 119 139 104 130 192 49 237 169 226 108 127 200 189 187 196 235 128 142 49 128 144 232 156 214 218 171 183 92 29 85 214 56 214 3 182 13 81 211 243 168 42 197 102 99 160 228 223 93 156 191 50 62 30 231 177 83 30 151 162 18 159)
#f
())
#(227
"CVE-2017-11185: signature=n"
#vu8(49 50 51 52 48 48)
#vu8(227 174 125 229 191 68 222 125 53 126 35 140 141 255 6 60 167 19 71 7 119 171 120 107 73 88 132 231 169 186 29 222 101 222 125 43 91 227 242 183 209 131 12 246 202 142 213 192 93 63 9 74 170 235 29 210 228 178 237 224 134 19 16 154 155 163 76 126 43 248 69 2 37 151 67 116 69 159 22 218 44 20 25 44 99 121 133 254 190 187 239 1 240 56 30 120 208 253 99 183 96 56 245 227 211 93 199 210 36 57 99 54 106 245 215 104 95 27 207 201 157 203 145 233 76 147 1 144 104 53 49 34 237 208 60 195 230 21 225 124 27 241 221 124 67 218 232 111 71 164 2 56 251 89 64 65 206 189 186 37 243 254 149 147 166 195 41 183 247 196 118 234 183 98 93 23 186 123 231 136 105 54 183 51 248 220 230 230 201 55 245 136 218 19 21 193 17 122 189 41 200 56 149 217 89 136 209 127 159 215 98 57 96 216 228 51 215 198 132 21 7 255 47 170 195 110 14 25 164 30 178 204 205 178 162 192 250 233 102 113 154 153 210 3 201 36 52 155 192 238 161 55 78 253 62 35 9 155 45 24 121 34 1 111 208 20 8 117 32 166 115 99 104 115 34 185 13 122 137 13 143 68 100 168 199 148 210 163 242 7 12 205 59 14 187 202 43 66 187 248 235 166 242 192 191 128 8 181 97 110 231 184 22 41 235 255 151 169 58 91 134 25 137 218 161 13 167 200 227 188 123 12 219 9 95 108 225 24 92 248 253 61 202 3 94 179 229 5 203 224 34 216 29 147 148 90 20 72 6 185 254 11 160 127 58 185 199 14 114 181 251 119 172 110 76 126 3 170 45 206 124 94 242 39 171 161 172 212 140 29 147 224 226 111 1 232 241 228 58 169 120 128 209 93 108 146 75 6 13 31 172 226 29 3 167 150 200 99 1 244 167 67 57 228 114 178 249 108 208 117 87 65 203 157 243 83 80 119 56 26 218 132 209 188 8 70 166 196 76 138 141 60 254 27 122 153 19 209 243 215 175 44 94 164 230 124 224 167 237 60 0 88 32 111 209 58 217 204 173 90 130 18 243 236 215 136 54 138 107 97 72 23 140 124 94 168 214 211 133 34 127 44 118 160 71 33 110 94 32 107 30 209)
#f
())
#(228
"the signature is 2 bytes too long"
#vu8(49 50 51 52 48 48)
#vu8(227 174 125 229 191 68 222 125 53 126 35 140 141 255 6 60 167 19 71 7 119 171 120 107 73 88 132 231 169 186 29 222 101 222 125 43 91 227 242 183 209 131 12 246 202 142 213 192 93 63 9 74 170 235 29 210 228 178 237 224 134 19 16 154 155 163 76 126 43 248 69 2 37 151 67 116 69 159 22 218 44 20 25 44 99 121 133 254 190 187 239 1 240 56 30 120 208 253 99 183 96 56 245 227 211 93 199 210 36 57 99 54 106 245 215 104 95 27 207 201 157 203 145 233 76 147 1 144 104 53 49 34 237 208 60 195 230 21 225 124 27 241 221 124 67 218 232 111 71 164 2 56 251 89 64 65 206 189 186 37 243 254 149 147 166 195 41 183 247 196 118 234 183 98 93 23 186 123 231 136 105 54 183 51 248 220 230 230 201 55 245 136 218 19 21 193 17 122 189 41 200 56 149 217 89 136 209 127 159 215 98 57 96 216 228 51 215 198 132 21 7 255 47 170 195 110 14 25 164 30 178 204 205 178 162 192 250 233 102 113 154 153 210 3 201 36 52 155 192 238 161 55 78 253 62 35 9 155 45 24 121 34 1 111 208 20 8 117 32 166 115 99 104 115 34 185 13 122 137 13 143 68 100 168 199 148 210 163 242 7 12 205 59 14 187 202 43 66 187 248 235 166 242 192 191 128 8 181 97 110 231 184 22 41 235 255 151 169 58 91 134 25 137 218 161 13 167 200 227 188 123 12 219 9 95 108 225 24 92 248 253 61 202 3 94 179 229 5 203 224 34 216 29 147 148 90 20 72 6 185 254 11 160 127 58 185 199 14 114 181 251 119 172 110 76 126 3 170 45 206 124 94 242 39 171 161 172 212 140 29 147 224 226 111 1 232 241 228 58 169 120 128 209 93 108 146 75 6 13 31 172 226 29 3 167 150 200 99 1 244 167 67 57 228 114 178 249 108 208 117 87 65 203 157 243 83 80 119 56 26 218 132 209 188 8 70 166 196 76 138 141 60 254 27 122 153 19 209 243 215 175 44 94 164 230 124 224 167 237 60 0 88 32 111 209 58 217 204 173 90 130 18 243 236 215 136 54 138 107 97 72 23 140 124 94 168 214 211 133 34 127 44 118 160 71 33 110 94 32 107 30 209 0 0)
#f
())
#(229
"the signature is empty"
#vu8(49 50 51 52 48 48)
#vu8()
#f
())
#(230
"the signature has value 0"
#vu8(49 50 51 52 48 48)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
#f
())
#(231
"the signature has value 1"
#vu8(49 50 51 52 48 48)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1)
#f
())
#(232
"the signature has value 2"
#vu8(49 50 51 52 48 48)
#vu8(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2)
#f
())
#(233
"the signature has value n-1"
#vu8(49 50 51 52 48 48)
#vu8(227 174 125 229 191 68 222 125 53 126 35 140 141 255 6 60 167 19 71 7 119 171 120 107 73 88 132 231 169 186 29 222 101 222 125 43 91 227 242 183 209 131 12 246 202 142 213 192 93 63 9 74 170 235 29 210 228 178 237 224 134 19 16 154 155 163 76 126 43 248 69 2 37 151 67 116 69 159 22 218 44 20 25 44 99 121 133 254 190 187 239 1 240 56 30 120 208 253 99 183 96 56 245 227 211 93 199 210 36 57 99 54 106 245 215 104 95 27 207 201 157 203 145 233 76 147 1 144 104 53 49 34 237 208 60 195 230 21 225 124 27 241 221 124 67 218 232 111 71 164 2 56 251 89 64 65 206 189 186 37 243 254 149 147 166 195 41 183 247 196 118 234 183 98 93 23 186 123 231 136 105 54 183 51 248 220 230 230 201 55 245 136 218 19 21 193 17 122 189 41 200 56 149 217 89 136 209 127 159 215 98 57 96 216 228 51 215 198 132 21 7 255 47 170 195 110 14 25 164 30 178 204 205 178 162 192 250 233 102 113 154 153 210 3 201 36 52 155 192 238 161 55 78 253 62 35 9 155 45 24 121 34 1 111 208 20 8 117 32 166 115 99 104 115 34 185 13 122 137 13 143 68 100 168 199 148 210 163 242 7 12 205 59 14 187 202 43 66 187 248 235 166 242 192 191 128 8 181 97 110 231 184 22 41 235 255 151 169 58 91 134 25 137 218 161 13 167 200 227 188 123 12 219 9 95 108 225 24 92 248 253 61 202 3 94 179 229 5 203 224 34 216 29 147 148 90 20 72 6 185 254 11 160 127 58 185 199 14 114 181 251 119 172 110 76 126 3 170 45 206 124 94 242 39 171 161 172 212 140 29 147 224 226 111 1 232 241 228 58 169 120 128 209 93 108 146 75 6 13 31 172 226 29 3 167 150 200 99 1 244 167 67 57 228 114 178 249 108 208 117 87 65 203 157 243 83 80 119 56 26 218 132 209 188 8 70 166 196 76 138 141 60 254 27 122 153 19 209 243 215 175 44 94 164 230 124 224 167 237 60 0 88 32 111 209 58 217 204 173 90 130 18 243 236 215 136 54 138 107 97 72 23 140 124 94 168 214 211 133 34 127 44 118 160 71 33 110 94 32 107 30 208)
#f
())
#(234
"the signature has value n+1"
#vu8(49 50 51 52 48 48)
#vu8(227 174 125 229 191 68 222 125 53 126 35 140 141 255 6 60 167 19 71 7 119 171 120 107 73 88 132 231 169 186 29 222 101 222 125 43 91 227 242 183 209 131 12 246 202 142 213 192 93 63 9 74 170 235 29 210 228 178 237 224 134 19 16 154 155 163 76 126 43 248 69 2 37 151 67 116 69 159 22 218 44 20 25 44 99 121 133 254 190 187 239 1 240 56 30 120 208 253 99 183 96 56 245 227 211 93 199 210 36 57 99 54 106 245 215 104 95 27 207 201 157 203 145 233 76 147 1 144 104 53 49 34 237 208 60 195 230 21 225 124 27 241 221 124 67 218 232 111 71 164 2 56 251 89 64 65 206 189 186 37 243 254 149 147 166 195 41 183 247 196 118 234 183 98 93 23 186 123 231 136 105 54 183 51 248 220 230 230 201 55 245 136 218 19 21 193 17 122 189 41 200 56 149 217 89 136 209 127 159 215 98 57 96 216 228 51 215 198 132 21 7 255 47 170 195 110 14 25 164 30 178 204 205 178 162 192 250 233 102 113 154 153 210 3 201 36 52 155 192 238 161 55 78 253 62 35 9 155 45 24 121 34 1 111 208 20 8 117 32 166 115 99 104 115 34 185 13 122 137 13 143 68 100 168 199 148 210 163 242 7 12 205 59 14 187 202 43 66 187 248 235 166 242 192 191 128 8 181 97 110 231 184 22 41 235 255 151 169 58 91 134 25 137 218 161 13 167 200 227 188 123 12 219 9 95 108 225 24 92 248 253 61 202 3 94 179 229 5 203 224 34 216 29 147 148 90 20 72 6 185 254 11 160 127 58 185 199 14 114 181 251 119 172 110 76 126 3 170 45 206 124 94 242 39 171 161 172 212 140 29 147 224 226 111 1 232 241 228 58 169 120 128 209 93 108 146 75 6 13 31 172 226 29 3 167 150 200 99 1 244 167 67 57 228 114 178 249 108 208 117 87 65 203 157 243 83 80 119 56 26 218 132 209 188 8 70 166 196 76 138 141 60 254 27 122 153 19 209 243 215 175 44 94 164 230 124 224 167 237 60 0 88 32 111 209 58 217 204 173 90 130 18 243 236 215 136 54 138 107 97 72 23 140 124 94 168 214 211 133 34 127 44 118 160 71 33 110 94 32 107 30 210)
#f
())
#(235
"the signature has value -1"
#vu8(49 50 51 52 48 48)
#vu8(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
#f
())
#(236
"RSASSA-PSS signature"
#vu8(49 50 51 52 48 48)
#vu8(85 107 176 38 215 59 77 137 73 201 77 178 116 11 108 251 177 113 55 182 156 242 105 186 95 27 231 54 171 110 176 116 108 183 255 188 93 125 17 153 91 32 83 34 112 19 213 16 43 148 132 197 159 82 24 83 217 159 150 30 70 97 25 116 244 127 57 50 168 225 248 42 63 94 176 71 207 124 123 252 99 181 220 248 110 255 174 52 186 33 98 135 250 35 213 215 158 126 162 67 154 173 7 253 117 30 25 1 17 48 141 155 73 165 36 219 124 59 12 147 157 144 18 249 194 243 237 217 83 65 118 171 32 150 212 227 209 25 85 102 208 114 227 222 239 33 69 57 189 112 34 63 113 46 196 95 138 40 6 6 4 226 156 207 110 80 49 67 44 150 35 25 13 209 148 167 155 234 22 161 181 23 69 242 252 51 242 212 34 156 213 67 161 209 151 129 53 37 198 85 179 77 239 153 144 252 247 93 234 191 101 179 37 129 95 128 213 68 82 138 6 57 56 60 186 209 45 24 212 16 58 191 182 52 167 185 221 104 212 22 96 10 164 190 225 155 190 223 242 111 129 237 145 225 25 189 205 227 202 82 121 46 42 94 178 10 76 146 127 150 178 56 187 71 138 179 18 48 144 30 185 159 133 109 12 146 145 95 186 51 147 147 209 172 215 242 146 112 183 40 211 242 102 20 198 200 148 193 22 147 210 213 42 137 218 55 101 48 243 53 108 218 121 143 31 249 130 119 232 244 105 137 94 102 253 205 142 104 93 102 62 154 75 155 37 135 70 38 204 236 56 225 172 223 23 98 226 8 82 114 120 84 205 253 164 104 41 81 0 12 107 65 42 29 3 68 170 79 122 19 172 26 106 248 211 75 215 136 28 132 73 230 69 148 13 248 112 41 45 199 4 147 20 159 96 157 178 98 74 211 236 41 61 134 102 189 142 109 141 235 98 177 111 184 142 102 44 163 47 153 171 58 122 153 36 127 155 175 158 186 163 203 45 208 91 17 13 82 136 85 0 66 221 172 246 3 56 142 252 161 73 61 161 201 187 146 202 200 86 245 234 203 140 127 181 101 14 146 136 99 91 108 68 164 123 93 111 211 108 65 99 122 109 225 236 235 19 88 113 231 71 49 140 39 253 52 31 213 211 235 171 112)
#f
())
#(237
"RSASSA-PSS signature"
#vu8(49 50 51 52 48 48)
#vu8(175 135 94 218 47 66 67 172 205 148 43 249 171 247 235 137 38 12 54 93 100 230 16 153 121 97 179 39 137 20 195 48 230 7 202 131 66 132 123 2 201 202 145 107 31 81 194 175 221 149 34 156 156 62 29 51 220 219 163 112 244 114 6 10 63 126 225 215 76 134 103 187 137 69 182 241 11 222 206 201 106 150 153 137 95 47 197 143 33 226 53 213 79 41 136 207 120 210 123 101 3 123 123 70 85 36 18 211 14 162 180 225 217 97 103 185 247 32 244 112 75 255 9 227 191 110 43 168 153 68 93 235 219 9 204 158 6 7 143 77 191 23 148 129 54 98 213 34 194 92 14 51 70 19 44 83 227 27 2 114 60 208 37 42 192 147 46 1 113 236 241 28 239 115 236 248 238 233 206 35 243 206 102 250 99 1 5 12 142 142 169 106 209 54 150 137 38 117 63 189 9 164 218 1 118 232 227 217 245 114 212 133 121 98 208 74 175 51 20 95 212 97 51 41 252 75 59 80 194 143 77 67 213 67 23 117 47 152 61 234 84 50 202 136 239 208 53 206 131 157 9 134 126 13 132 237 87 227 49 235 126 210 222 116 221 205 98 93 19 243 187 88 107 180 219 219 251 163 78 176 215 33 48 166 42 193 0 121 128 124 218 251 64 198 56 63 8 175 65 9 71 45 46 230 67 12 60 48 27 214 188 26 152 61 220 237 134 24 176 141 178 253 77 220 160 124 159 72 182 104 201 214 242 203 39 85 162 158 25 202 12 141 3 125 61 183 145 148 80 144 13 33 127 228 38 240 84 68 58 170 214 190 34 40 95 170 146 60 247 25 53 12 218 237 200 115 62 206 109 98 38 75 244 160 220 27 184 134 70 241 87 104 106 64 83 17 26 175 222 253 65 45 61 127 89 162 84 72 41 237 66 144 56 241 69 47 243 109 78 139 41 125 11 67 20 128 144 169 149 148 75 66 37 189 245 25 166 49 93 98 223 85 93 35 55 247 239 7 151 95 15 221 236 239 130 239 12 165 187 65 68 77 137 134 4 5 252 6 168 220 108 147 189 35 102 58 151 124 104 255 136 144 188 210 9 136 239 196 77 246 137 27 157 174 163 175 8 49 55 162 31 55 118 242 232 84 67 179 89 237 19 231)
#f
())
#(238
"RSASSA-PSS signature"
#vu8(49 50 51 52 48 48)
#vu8(207 186 211 4 224 88 7 175 80 95 85 144 164 158 202 99 15 196 61 249 149 14 95 67 178 18 138 69 215 39 31 45 220 134 216 55 74 240 139 180 120 188 46 227 135 63 136 60 160 221 65 245 170 133 59 196 66 220 245 182 251 31 237 57 93 141 125 113 241 154 71 226 124 220 121 14 99 244 187 109 23 250 173 15 88 239 255 26 54 4 68 72 219 136 131 50 91 41 3 8 202 245 39 34 85 190 29 21 39 111 186 64 57 32 103 98 255 163 182 60 253 7 200 46 203 224 248 182 131 69 247 72 196 39 41 239 5 238 135 215 213 216 59 246 247 8 101 141 124 69 167 244 87 195 24 127 118 226 226 230 155 199 78 96 187 114 154 203 209 191 172 91 121 236 216 149 173 164 178 201 186 67 62 229 19 182 81 22 143 194 55 9 188 117 242 122 200 247 147 54 84 61 68 175 57 16 204 246 111 255 120 17 59 16 61 233 211 208 102 81 87 235 193 67 85 233 4 142 4 203 165 24 130 219 157 112 244 21 5 229 52 61 216 40 148 255 39 116 23 252 107 149 36 144 75 50 101 95 240 219 216 137 150 113 182 75 143 78 107 56 120 85 61 33 218 58 184 66 193 44 12 196 205 136 188 19 27 238 65 137 109 3 55 234 136 125 199 41 135 73 34 244 207 91 36 34 150 120 125 185 112 155 35 124 240 185 167 113 44 167 34 236 198 132 44 17 97 45 215 157 186 107 63 218 17 89 123 170 205 68 160 5 25 191 134 79 189 211 180 238 187 146 59 126 238 41 170 169 104 208 116 203 69 239 179 48 76 185 35 178 71 134 127 129 155 182 20 81 134 203 247 121 181 196 216 185 90 221 27 100 155 56 206 48 100 121 232 104 75 237 165 92 246 139 42 162 51 89 169 3 76 107 55 229 66 98 191 84 230 204 60 149 159 60 123 137 6 234 21 134 76 72 142 51 187 236 139 93 70 80 84 96 39 152 53 158 237 184 12 157 255 36 99 251 22 209 83 176 32 10 160 18 34 251 59 45 216 68 249 21 239 176 86 18 168 241 240 55 27 45 102 138 104 118 138 22 141 80 122 247 118 90 232 5 186 62 220 31 129 224 223 196 149 216 36 33 45 28 176 0 18 167)
#f
())
#(239
"RSASSA-PSS signature"
#vu8(49 50 51 52 48 48)
#vu8(146 82 143 69 156 27 208 119 93 140 70 85 251 47 213 232 4 15 50 101 187 87 254 30 229 83 196 143 52 115 143 61 90 210 174 64 214 3 127 2 162 57 137 102 158 14 233 131 95 63 199 68 66 19 85 143 46 218 155 185 72 92 59 129 217 159 225 174 78 38 178 44 213 234 114 104 212 137 210 145 212 245 228 127 92 172 143 173 49 2 124 197 97 56 213 181 91 62 69 176 92 200 88 175 214 237 146 190 193 129 225 23 107 132 236 51 241 52 128 26 186 134 32 178 148 178 35 129 101 184 24 45 211 12 24 49 48 126 195 89 68 225 97 20 105 164 88 237 62 238 193 72 5 86 47 136 235 167 233 82 190 185 193 154 142 201 198 160 199 226 65 141 10 222 81 156 22 117 238 59 2 155 250 210 12 67 78 207 43 17 5 231 101 146 191 176 52 19 128 173 196 19 213 102 230 44 147 8 245 157 110 231 23 210 92 90 40 135 175 28 131 65 18 123 105 1 86 24 106 125 38 95 236 185 154 8 66 28 137 200 218 130 156 110 36 47 86 24 118 145 155 34 158 115 206 162 240 105 77 139 255 40 34 49 173 155 1 14 77 28 101 72 60 42 207 231 14 13 132 10 178 94 93 24 30 215 255 136 79 69 212 140 69 147 74 96 255 166 203 238 252 255 133 212 187 59 97 135 167 209 69 74 44 8 197 250 34 39 21 187 251 247 7 164 146 172 143 162 167 9 104 106 207 70 105 102 130 52 115 216 42 125 115 102 226 83 164 19 114 250 34 0 205 79 60 196 215 138 75 194 196 37 165 61 21 128 240 227 236 193 123 72 188 85 168 24 86 136 243 54 42 94 247 203 84 126 244 82 70 6 173 62 49 127 13 16 39 5 155 234 136 160 237 127 223 68 81 88 56 227 160 63 224 89 168 4 83 75 72 40 1 229 177 204 53 238 107 189 205 76 106 245 56 153 204 151 69 114 36 184 71 12 183 44 76 65 203 24 12 166 57 225 141 69 169 205 179 141 39 217 168 44 4 21 124 112 213 172 24 182 35 231 158 235 159 247 71 40 155 133 128 37 115 86 231 162 72 143 8 17 80 145 144 175 241 199 223 227 226 128 25 245 248 97 84 58 240 0 79 137 126 231)
#f
())))
| false |
ef28f93f809d703b52c7ebd09d9c0992458f15f6
|
47bf2cde5a0c44beaea30155a6944b4d95d33ca0
|
/hw8-harding.scm
|
8f092c774dec327743fef970124a39cf391d50c5
|
[] |
no_license
|
nathard/SchemeExercises
|
5199235db74df7a8a2a4ad9d45394407ff82145f
|
61d908412085f87ee044ba995f675478cb88edfc
|
refs/heads/master
| 2021-01-19T14:36:36.295961 | 2013-08-08T05:19:11 | 2013-08-08T05:19:11 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 17,427 |
scm
|
hw8-harding.scm
|
#lang eopl
; This file contains starting code for Homework 8 in Com S 342
; Much of this is derived from the source code for EOPL, 3rd edition.
(require (lib "chapter3/let-lang/drscheme-init.scm" "eopl3")) ; for run-tests!
; PROBLEM 1
; This is a sample of problem 1 a
(define sample-run
(lambda()
(run "-(1, 2)")))
; This is a sample of problem 1 b
(define sample-scan
(lambda()
(scan&parse "-(1, 2)")))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Now UNCOMMENT the lines below and write your answers for problem 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ; Your answers:
(define run-const-exp
(lambda()
; ; write an expression that runs a const-exp here
(run "11")
))
;
(define run-diff-exp
(lambda()
; ; write an expression that runs a diff-exp here
(run "-(8, 3)")
))
;
(define run-zero?-exp
(lambda()
; ; write an expression that runs a zero?-exp here
(run "zero? (0)")
))
;
(define run-if-exp
(lambda()
; ; write an expression that runs a if-exp here
(run "if zero? (0) then x else y")
))
;
(define run-var-exp
(lambda()
; ; write an expression that runs a var-exp here
(run "x")
))
;
(define run-let-exp
(lambda()
; ; write an expression that runs a var-exp here
(run "let p = 5 in -(p, 3)")
))
(define scan-const-exp
(lambda()
; ; write an expression that scans a const-exp here
(scan&parse "11")
))
;
(define scan-diff-exp
(lambda()
; ; write an expression that scans a diff-exp here
(scan&parse "-(1, 2)")
))
;
(define scan-zero?-exp
(lambda()
; ; write an expression that scans a zero?-exp here
(scan&parse "zero? (0)")
))
;
(define scan-if-exp
(lambda()
; ; write an expression that scans a if-exp here
(scan&parse "if zero? (0) then x else y")
))
;
(define scan-var-exp
(lambda()
; ; write an expression that scans a var-exp here
(scan&parse "x")
))
;
(define scans-let-exp
(lambda()
; ; write an expression that scans a var-exp here
(scan&parse "let p = 5 in -(p, 3)")
))
;;;;;;;;;;;;;;;; TOP LEVEL FUNCTION ;;;;;;;;;;;;;;;;
;; run : String -> ExpVal
;; Page: 71
(define run
(lambda (string)
(value-of-program (scan&parse string))))
;;;;;;;;;;;;;;;; GRAMMATICAL SPECIFICATION ;;;;;;;;;;;;;;;;
;; Following defines legal tokens in the let language
(define the-lexical-spec
'((whitespace (whitespace) skip)
(comment ("%" (arbno (not #\newline))) skip)
(identifier
(letter (arbno (or letter digit "_" "-" "?")))
symbol)
(number (digit (arbno digit)) number)
(number ("-" digit (arbno digit)) number)
))
; Following defines the grammar for the let language
; In the description symbols enclosed in "term" represent
; terminals and others are non-terminals. For example,
; "(" is a terminal and so is "zero?" as these do not
; require further derivation. Note that the terminals
; number and identifier are defined by the lexical
; specification above.
(define the-grammar
; program ::= expression
'((program (expression) a-program)
; expression := number
(expression (number) const-exp)
; expression := "-" "(" expression "," expression ")"
(expression
("-" "(" expression "," expression ")")
diff-exp)
; expression := "zero?" "(" expression ")"
(expression
("zero?" "(" expression ")")
zero?-exp)
; expression := "if" expression "then" expression "else" expression
(expression
("if" expression "then" expression "else" expression)
if-exp)
; expression := identifier
(expression (identifier) var-exp)
; expression := "let" identifier "=" expression "in" expression
(expression
("let" identifier "=" expression "in" expression)
let-exp)
; expression := "/" "(" expression "," expression ")"
(expression
("/" "(" expression "," expression ")")
div-exp)
; expression := "+" "(" separated-list expression ","")"
(expression
("+" "(" (separated-list expression ",") ")" )
add-exp)
; expression := "*" "(" separated-list expression ","")"
(expression
("*" "(" (separated-list expression ",") ")" )
mult-exp)
; expression := "list" "(" expression ("," expression)* ")"
(expression
("list" "(" (separated-list expression ",") ")" )
list-exp)
; expression ::= "unpack" {identifier}* = expression in expression
(expression
("unpack" (arbno identifier) "=" expression "in" expression)
unpack-exp)
; expression := "empty-stack"
(expression
("empty-stack")
empty-stack-exp)
; expression := "push" "(" expression expression ")"
(expression
("push" "(" expression expression ")")
push-exp)
; expression := "pop" "(" expression ")"
(expression
("pop" "(" expression ")")
pop-exp)
; expression := "top" "(" expression ")"
(expression
("top" "(" expression ")")
top-exp)
; expression := "empty-stack?" "(" expression ")"
(expression
("empty-stack?" "(" expression ")")
empty-stack?-exp)
))
;;;;;;;;;;;;;;;; SLLGEN BOILERPLATE ;;;;;;;;;;;;;;;;
(sllgen:make-define-datatypes the-lexical-spec the-grammar)
(define show-the-datatypes
(lambda () (sllgen:list-define-datatypes the-lexical-spec the-grammar)))
(define scan&parse
(sllgen:make-string-parser the-lexical-spec the-grammar))
(define just-scan
(sllgen:make-string-scanner the-lexical-spec the-grammar))
;;;;;;;;;;;;;;;; EXPRESSED VALUES ;;;;;;;;;;;;;;;;
;;; an expressed value is either a number or a boolean.
(define-datatype expval expval?
(num-val
(value number?))
(bool-val
(boolean boolean?))
; Problem 3: this data-type is already extended
(list-val
(list list?))
; Problem 5:
(stack-val
(stk stack?))
(push
(value expval?) (stk stack?))
(empty-stack))
;;; predicates
(define stack?
(lambda (exp)
(cases expval exp
(stack-val (s) #t)
(push (s e) #t)
(empty-stack () #t)
(else #f))))
;;; extractors:
;; expval->num : ExpVal -> Int
;; Page: 70
(define expval->num
(lambda (v)
(cases expval v
(num-val (num) num)
(else (expval-extractor-error 'num v)))))
;; expval->bool : ExpVal -> Bool
;; Page: 70
(define expval->bool
(lambda (v)
(cases expval v
(bool-val (bool) bool)
(else (expval-extractor-error 'bool v)))))
; Problem 3
(define expval->list
(lambda (v)
(cases expval v
(list-val (lst) lst)
(else (expval-extractor-error 'list v)))))
;Problem 5
(define expval->stack
(lambda (v)
(cases expval v
(push (s e) s)
(stack-val (s) s)
(else (expval-extractor-error 'stack v)))))
(define expval->stack-val
(lambda (v)
(cases expval v
(push (s e) s)
(else (expval-extractor-error 'stack v)))))
(define expval-extractor-error
(lambda (variant value)
(eopl:error 'expval-extractors "Looking for a ~s, found ~s"
variant value)))
;;;;;;;;;;;;;;;; ENVIRONMENT STRUCTURE ;;;;;;;;;;;;;;;;
;; example of a data type built without define-datatype
(define empty-env-record
(lambda ()
'()))
(define extended-env-record
(lambda (sym val old-env)
(cons (list sym val) old-env)))
(define empty-env-record? null?)
(define environment?
(lambda (x)
(or (empty-env-record? x)
(and (pair? x)
(symbol? (car (car x)))
(expval? (cadr (car x)))
(environment? (cdr x))))))
(define extended-env-record->sym
(lambda (r)
(car (car r))))
(define extended-env-record->val
(lambda (r)
(cadr (car r))))
(define extended-env-record->old-env
(lambda (r)
(cdr r)))
;;;;;;;;;;;;;;;; INITIAL ENVIRONMENT ;;;;;;;;;;;;;;;;
;; init-env : () -> Env
;; usage: (init-env) = [i=1, v=5, x=10]
;; (init-env) builds an environment in which i is bound to the
;; expressed value 1, v is bound to the expressed value 5, and x is
;; bound to the expressed value 10.
;; Page: 69
(define init-env
(lambda ()
(extend-env
'i (num-val 1)
(extend-env
'v (num-val 5)
(extend-env
'x (num-val 10)
(empty-env))))))
;;;;;;;;;;;;;;;; ENVIRONMENT CONSTRUCTORS AND OBSERVERS ;;;;;;;;;;;;;;;;
(define empty-env
(lambda ()
(empty-env-record)))
(define empty-env?
(lambda (x)
(empty-env-record? x)))
(define extend-env
(lambda (sym val old-env)
(extended-env-record sym val old-env)))
(define apply-env
(lambda (env search-sym)
(if (empty-env? env)
(eopl:error 'apply-env "No binding for ~s" search-sym)
(let ((sym (extended-env-record->sym env))
(val (extended-env-record->val env))
(old-env (extended-env-record->old-env env)))
(if (eqv? search-sym sym)
val
(apply-env old-env search-sym))))))
; Problem 4
(define extend-env*
(lambda (lst1 lst2 env)
(if (null? lst1) env
(if (null? (cdr lst1))
(extend-env (car lst1) (car lst2) env)
(extend-env* (cdr lst1) (cdr lst2) (extend-env (car lst1) (car lst2) env))))))
;;;;;;;;;;;;;;;; THE INTERPRETER ;;;;;;;;;;;;;;;;
;; value-of-program : Program -> ExpVal
;; Page: 71
(define value-of-program
(lambda (pgm)
(cases program pgm
(a-program (exp1)
(value-of exp1 (init-env))))))
;; value-of : Exp * Env -> ExpVal
;; Page: 71
(define value-of
(lambda (exp env)
(cases expression exp
;Semantics of constant expression
(const-exp (num) (num-val num))
;Semantics of variable expression
(var-exp (var) (apply-env env var))
;Semantics of difference expression
(diff-exp (exp1 exp2)
(let ((val1 (value-of exp1 env))
(val2 (value-of exp2 env)))
(let ((num1 (expval->num val1))
(num2 (expval->num val2)))
(num-val
(- num1 num2)))))
;Semantics of zero test expression
(zero?-exp (exp1)
(let ((val1 (value-of exp1 env)))
(let ((num1 (expval->num val1)))
(if (zero? num1)
(bool-val #t)
(bool-val #f)))))
;Semantics of if expression
(if-exp (exp1 exp2 exp3)
(let ((val1 (value-of exp1 env)))
(if (expval->bool val1)
(value-of exp2 env)
(value-of exp3 env))))
;Semantics of let expression
(let-exp (var exp1 body)
(let ((val1 (value-of exp1 env)))
(value-of body
(extend-env var val1 env))))
;Semantics of div expression
(div-exp (exp1 exp2)
(let ((val1 (value-of exp1 env))
(val2 (value-of exp2 env)))
(let ((num1 (expval->num val1))
(num2 (expval->num val2)))
(num-val
(/ num1 num2)))))
;Semantics of add expression
(add-exp (exp1)
(num-val (if (null? exp1) 0
(+ (expval->num (value-of (car exp1) env))
(expval->num (value-of (add-exp (cdr exp1)) env))))))
;Semantics of mult expression
(mult-exp (exp1)
(num-val (if (null? exp1) 1
(* (expval->num (value-of (car exp1) env))
(expval->num (value-of (mult-exp (cdr exp1)) env))))))
;Semantics of list expression
(list-exp (exp1)
(list-val (if (null? exp1) '()
(cons (value-of (car exp1) env)
(expval->list (value-of (list-exp (cdr exp1)) env))))))
;Semantics of unpack expression
(unpack-exp (lst exp1 exp2)
(if (eq? (length (expval->list (value-of exp1 env))) (length lst))
(value-of exp2 (extend-env* lst (expval->list (value-of exp1 env)) env))
(eopl:error 'error "number of identifiers and values are unequal in list")))
;Semantics of stack
(empty-stack-exp ()
(stack-val (empty-stack)))
(push-exp (exp stk)
(stack-val (push (value-of exp env) (expval->stack (value-of stk env)))))
(pop-exp (stk)
(stack-val (expval->stack (expval->stack (value-of stk env)))))
(top-exp (stk)
(expval->stack-val (expval->stack (value-of stk env))))
(empty-stack?-exp (stk)
(bool-val (equal? (empty-stack) (expval->stack (value-of stk env)))))
)))
;;;;;;;;;;;;;;;; OTHER FUNCTIONS ;;;;;;;;;;;;;;;;
;;;;;; HELPFUL FOR TESTING AND DEBUGGING ;;;;;;;;
;; run-all : () -> unspecified
;; runs all the tests in test-list, comparing the results with
;; equal-answer?
(define test-list
'(
(plus1 "+(1, 1)" 2)
(plus2 "+(x, 3)" 13)
(plus3 "+(1, 2, 3)" 6)
(mult1 "*(1, 2)" 1)
(mult2 "*(2, 2, 2)" 8)
(mult3 "*(2, x)" 20)
(div1 "/(1, 1)" 1)
(div2 "/(2, 1)" 2)
(div3 "/(20, x)" 2)
(list1 "list(1, 2, 3)" (1 2 3))
(list2 "list()" ())
(list3 "list(x)" (10))
(unpack1 "unpack x y z = list(1 2 3) in - (z, 3)" 0)
(unpack1 "unpack x = list(0) in zero?(x)" #t)
))
(define run-all
(lambda ()
(run-tests! run equal-answer? test-list)))
(define equal-answer?
(lambda (ans correct-ans)
(equal? ans (sloppy->expval correct-ans))))
(define sloppy->expval
(lambda (sloppy-val)
(cond
((number? sloppy-val) (num-val sloppy-val))
((boolean? sloppy-val) (bool-val sloppy-val))
((list? sloppy-val) (list-val
(sloppylst->expvallst sloppy-val)))
(else
(eopl:error 'sloppy->expval
"Can't convert sloppy value to expval: ~s"
sloppy-val)))))
(define sloppylst->expvallst
(lambda (sloppy-lst)
(cond
((null? sloppy-lst) ())
(else (cons (sloppy->expval (car sloppy-lst))
(sloppylst->expvallst (cdr sloppy-lst)))))))
;; run-one : symbol -> expval
;; (run-one sym) runs the test whose name is sym
(define run-one
(lambda (test-name)
(let ((the-test (assoc test-name test-list)))
(cond
((assoc test-name test-list)
=> (lambda (test)
(run (cadr test))))
(else (eopl:error 'run-one "no such test: ~s" test-name))))))
;; run-these-tests : () -> unspecified
;; runs these test given as argument, comparing the results with
;; equal-answer?
(define run-these-tests
(lambda (tests)
(run-tests! run equal-answer? tests)))
;; (with-trace) run fun while tracing important calls in interpreter.
(define with-trace
(lambda (fun)
(begin
(trace run)
(trace scan&parse)
(trace value-of-program)
(trace value-of)
(fun)
(untrace run)
(untrace scan&parse)
(untrace value-of-program)
(untrace value-of)
)))
;; (run-with-trace) traces important calls in interpreter.
(define run-with-trace
(lambda (string)
(with-trace
(lambda ()
(run string)))))
;; (run-one-with-trace) runs a test while tracing important calls in interpreter.
(define run-one-with-trace
(lambda (test-name)
(with-trace
(lambda ()
(run-one test-name)))))
;; (runall-with-trace) similar to run-one-with-trace, but runs all tests.
(define runall-with-trace
(lambda ()
(with-trace run-all)))
; TESTS for HW 7
(define test-plus
(lambda ()
(run-these-tests
'(
(plus1 "+(1, 1)" 2)
(plus2 "+(x, 3)" 13)
(plus3 "+(1, 2, 3)" 6)
))))
(define test-mult
(lambda ()
(run-these-tests
'(
(mult1 "*(1, 2)" 2)
(mult2 "*(2, 2, 2)" 8)
(mult3 "*(2, x)" 20)
))))
(define test-div
(lambda ()
(run-these-tests
'(
(div1 "/(1, 1)" 1)
(div2 "/(2, 1)" 2)
(div3 "/(20, x)" 2)
))))
(define test-lists
(lambda()
(run-these-tests
'(
(list1 "list(1, 2, 3)" (1 2 3))
(list2 "list()" ())
(list3 "list(x)" (10))
))))
(define test-unpack
(lambda()
(run-these-tests
'(
(unpack1 "unpack x y z = list(1, 2, 3) in -(z, 3)" 0)
(unpack1 "unpack x = list(0) in zero?(x)" #t)
))))
| false |
381a1e586ff559c5a1d4e6f6dda73f39ce27814e
|
4bd59493b25febc53ac9e62c259383fba410ec0e
|
/Scripts/Task/null-object/scheme/null-object.ss
|
a63432d22c69548f73f8c72f38f789ea0fe4eff6
|
[] |
no_license
|
stefanos1316/Rosetta-Code-Research
|
160a64ea4be0b5dcce79b961793acb60c3e9696b
|
de36e40041021ba47eabd84ecd1796cf01607514
|
refs/heads/master
| 2021-03-24T10:18:49.444120 | 2017-08-28T11:21:42 | 2017-08-28T11:21:42 | 88,520,573 | 5 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 15 |
ss
|
null-object.ss
|
(null? object)
| false |
a4be75871ba25851c5669253e356657468ec0a50
|
d8bdd07d7fff442a028ca9edbb4d66660621442d
|
/unit/scripts/test-demand.scm
|
4a5b7ef0e7b2671bcaa4cac6eddadb6a7826e64e
|
[] |
no_license
|
xprime480/scam
|
0257dc2eae4aede8594b3a3adf0a109e230aae7d
|
a567d7a3a981979d929be53fce0a5fb5669ab294
|
refs/heads/master
| 2020-03-31T23:03:19.143250 | 2020-02-10T20:58:59 | 2020-02-10T20:58:59 | 152,641,151 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 32 |
scm
|
test-demand.scm
|
(import (scripts lib5))
(sqr 5)
| false |
fde53d572f2dae90580e0c7c792ea98f269c9416
|
1b1828426867c9ece3f232aaad1efbd2d59ebec7
|
/Chapter 1/sicp1-39.scm
|
156a03bde84ec912d2f1ffbbc937aba58cc54905
|
[] |
no_license
|
vendryan/sicp
|
60c1338354f506e02c714a96f643275d35a7dc51
|
d42f0cc6f985aaf369f2760f962928381ca74332
|
refs/heads/main
| 2023-06-07T02:04:56.332591 | 2021-06-19T10:28:57 | 2021-06-19T10:28:57 | 369,958,898 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 708 |
scm
|
sicp1-39.scm
|
(define (abs x)
(if (< x 0)
(- x)
x))
(define (square x)
(* x x))
(define (even? x)
(= (remainder x 2) 0))
; Recursive process
(define (cont-frac combiner n d k)
(define (recur a)
(if (= a k)
(/ (n a) (d a))
(/ (n a)
(combiner (d a)
(recur (+ a 1))))))
(recur 1))
(define (tan-cf x k)
(define (expt-pattern n)
(cond ((= n 1) x)
(else (square x))))
(cont-frac -
expt-pattern
(lambda (n) (- (* 2 n) 1))
k))
; Compute tan using continued fraction
(display (tan-cf 0.7853981634 1000))
| false |
171a4dd21d49d30cd2c51acef2b8c912751fb242
|
d63c4c79d0bf83ae646d0ac023ee0528a0f4a879
|
/cs133/assn1/a1q2.ss
|
39775b46cf1ff40d4fe50a1e56d399ba4acd774a
|
[] |
no_license
|
stratigoster/UW
|
4dc31f08f7f1c9a958301105dcad481c39c5361f
|
7a4bff4f1476607c43278c488f70d01077b1566b
|
refs/heads/master
| 2021-07-07T04:52:01.543221 | 2011-08-15T05:08:48 | 2011-08-15T05:08:48 | 10,858,995 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,877 |
ss
|
a1q2.ss
|
;; pre-calculates the total number of days from the beginning of the year up to the beginning of the month
;; eg April=31+28+31
(define m2 31)
(define m3 (+ 28 m2))
(define m4 (+ 31 m3))
(define m5 (+ 30 m4))
(define m6 (+ 31 m5))
(define m7 (+ 30 m6))
(define m8 (+ 31 m7))
(define m9 (+ 31 m8))
(define m10 (+ 30 m9))
(define m11 (+ 31 m10))
(define m12 (+ 30 m11))
;; day-within-year: symbol num num -> num
;; to produce the day of the year that the date falls on in the Gregorian calendar
;; eg (day-within-year 'Sep 24 2000) => 268
(define (day-within-year month day year)
(cond
[(leap-year? year) (calc-days month (+ day 1))] ;; if leap year, adds 1 to the day
[else (calc-days month day)]))
; leap-year?: num -> boolean
;; to check whether a year is a leap year or not
;; Re: leap years are divisible by 400 and 4, but not 100
;; eg (leap-year? 2000) => true
(define (leap-year? year)
(cond
[(= 0 (remainder year 400)) true]
[(= 0 (remainder year 100)) false]
[(= 0 (remainder year 4)) true]
[else false]))
;; calc-days: symbol num -> num
;; adds up the total number of days from the beginning of the year to the date
(define (calc-days month day)
(cond
[(symbol=? month 'Jan) day]
[(symbol=? month 'Feb) (+ day m2)]
[(symbol=? month 'Mar) (+ day m3)]
[(symbol=? month 'Apr) (+ day m4)]
[(symbol=? month 'May) (+ day m5)]
[(symbol=? month 'Jun) (+ day m6)]
[(symbol=? month 'Jul) (+ day m7)]
[(symbol=? month 'Aug) (+ day m8)]
[(symbol=? month 'Sep) (+ day m9)]
[(symbol=? month 'Oct) (+ day m10)]
[(symbol=? month 'Nov) (+ day m11)]
[(symbol=? month 'Dec) (+ day m12)]))
;; tests
(= (day-within-year 'Sep 24 2000) 268)
(= (day-within-year 'Dec 31 2001) 365)
(= (day-within-year 'Jan 26 1987) 26)
(= (day-within-year 'Mar 12 1700) 71)
| false |
39609eb9ec3016fa7b178affa1f78292c12d7d95
|
4b480cab3426c89e3e49554d05d1b36aad8aeef4
|
/chapter-01/ex1.03-ashal.scm
|
4b23cfa347fd71a727e357cc356dc79df78490bd
|
[] |
no_license
|
tuestudy/study-sicp
|
a5dc423719ca30a30ae685e1686534a2c9183b31
|
a2d5d65e711ac5fee3914e45be7d5c2a62bfc20f
|
refs/heads/master
| 2021-01-12T13:37:56.874455 | 2016-10-04T12:26:45 | 2016-10-04T12:26:45 | 69,962,129 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,090 |
scm
|
ex1.03-ashal.scm
|
#lang scheme
(define (square x) (* x x))
(define (sum-of-squares x y z)
(+ (square x)
(square y)
(square z)))
(define (sum-of-two-big-numbers-squares x y z)
(- (sum-of-squares x y z)
(square (min x y z))))
(define (middle x y z)
(- (+ x y z)
(max x y z)
(min x y z)))
(define (sum-of-two-big-numbers-squares-2 x y z)
(sum-of-squares (max x y z) (middle x y z) 0))
(define (is-middle? x y z)
(or (and (>= x y) (<= x z))
(and (<= x y) (>= x z))))
(define (middle-2 x y z)
(cond ((is-middle? x y z) x)
((is-middle? y x z) y)
((is-middle? z x y) z)))
(define (sum-of-two-big-numbers-squares-3 x y z)
(sum-of-squares (max x y z) (middle-2 x y z) 0))
"all tests -----------------"
(and
(= (square 2) 4)
(= (sum-of-squares 1 2 3) 14)
(= (sum-of-two-big-numbers-squares 1 2 3) 13)
(= (middle 1 3 2) 2)
(= (sum-of-two-big-numbers-squares-2 1 2 3) 13)
(is-middle? 2 1 3)
(is-middle? 1 1 3)
(not (is-middle? 1 2 3))
(= (middle-2 1 2 3) 2)
(= (sum-of-two-big-numbers-squares-3 1 3 2) 13)
)
| false |
866f4ee240146b6dc578cbd9dfb146a24a34a251
|
958488bc7f3c2044206e0358e56d7690b6ae696c
|
/scheme/mitbatch.scm
|
e9cd1132ea0f2411603ad4c8c60cdaf706fab9a1
|
[] |
no_license
|
possientis/Prog
|
a08eec1c1b121c2fd6c70a8ae89e2fbef952adb4
|
d4b3debc37610a88e0dac3ac5914903604fd1d1f
|
refs/heads/master
| 2023-08-17T09:15:17.723600 | 2023-08-11T12:32:59 | 2023-08-11T12:32:59 | 40,361,602 | 3 | 0 | null | 2023-03-27T05:53:58 | 2015-08-07T13:24:19 |
Coq
|
UTF-8
|
Scheme
| false | false | 96 |
scm
|
mitbatch.scm
|
#!/usr/bin/mit-scheme
;; this batch file fails for mit-scheme
(display "Hello world!\n")
(quit)
| false |
6d1897f6dbecf5170c212c9b19304ec612f2d2be
|
8def8726df4eb28d7b22d123c7e3a208d5577999
|
/old/internal/design/binding-spaces.ss
|
f2d2ace7f17023ac3f33836f9191daf866954280
|
[] |
no_license
|
racket/old-web
|
9e0afa241fe443ddb5e9fa083d58c978ed38b459
|
d7b670c23e570d398257fbc7b658b3948a5f3d81
|
refs/heads/master
| 2022-11-11T09:46:58.220698 | 2020-06-25T13:12:02 | 2020-06-25T13:12:02 | 274,562,458 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,922 |
ss
|
binding-spaces.ss
|
#reader"../../common/html-script.ss"
(define title "Binding Spaces")
(define (run)
(write-tall-page title
@p{(@a[href: (string-append "http://list.cs.brown.edu/mailman/private/"
"plt-internal/2007-October/"
"thread.html#12848")]{
Original thread})}
@h2{Why Binding Spaces Make Sense}
@p{With the notable exception of module names, all bindings in PLT Scheme
use the same "binding space". (The word "namespace" is often used for
what I mean, but "namespace" has a different meaning in PLT Scheme.)
The binding space is the same even for names that work in mutually
distinct positions, which means that name collisions sometimes seem
gratuitous.}
@p{For example, a lexer regular-expression form like @tt{*} (Kleene star),
can be used only within the pattern positions of a @tt{lexer} form.
Those patterns are distinct from expression positions. Nevertheless,
lexer-form bindings are in the same space as expression-level bindings.
In particular, @tt{*} is also a MzScheme function; to use both the
lexer's @tt{*} and MzScheme's @tt{*} in a single scope, one of them has
to be renamed for prefixed, even though the two @tt{*}s work only in
mutually distinct positions.}
@p{Here are some other examples:
@ul{@li{The v4.0 @tt{require} form is macro-extensible, which means that
sub-forms like @tt{rename}, @tt{prefix} and @tt{all-except} need
bindings. Such bindings can only be used in a @tt{require}
form, and there are no expression positions inside a
@tt{require} form. Meanwhile, words like @tt{rename} and
@tt{prefix} are often nice names for function bindings within a
module. The v4.0 @tt{provide} form is similarly
macro-extensible.}
@li{Type positions in Typed Scheme are distinct from expression
positions.}
@li{Pattern variables bound by @tt{syntax-case} and
@tt{syntax-rules} can be used only in templates, and templates
have no expression positions. In his dissertation, Martin
Gasbichler argues in favor of a distinct space for
pattern-variable bindings.}}}
@p{Adding some concept of "space" or "dimension" to bindings would allow
short names, such as @tt{*} and @tt{rename}, to work for different
contexts within the same scope. Multiple spaces might also help
discourage symbolic comparisons (such as @tt{rename} in the current
@tt{require} form), which so often turns out to be the wrong idea
(usually because it doesn't support macro extension).}
@p{Meanwhile, the core macro/module system already has different binding
spaces for different phases --- even a @tt{for-label} space, which is
somewhat disconnected from phases. By analogy, then, maybe it makes
sense to build binding spaces into the core.}
@h2{Why Binding Spaces Aren't Worthwhile in the Core}
@p{Although the current macro+module system supports different spaces for
different phases, it's not clear that the different spaces are actually
useful. An identifier very rarely has different bindings in different
phases; normally, it's just a question of the phase levels in which an
identifier has its "usual" binding.}
@p{More significantly, it turns out that multiple binding spaces aren't
actually a generalization in the direction of @tt{for-label}. I
previously characterized @tt{for-label} as a kind of "dimension" instead
of "phase",but now I think that it really is a kind of infinitely
distant phase (i.e., you never get around to evaluating anything in that
phase). Unlike different spaces for @tt{lexer} and @tt{require}
bindings, a @tt{for-label} import implies different module-invocation
actions than @tt{for-run} or @tt{for-syntax}. Also, combining
@tt{for-label} with @tt{for-expand} makes no sense, whereas a
hypothetical @tt{for-require}, @tt{for-provide}, or @tt{for-type}
dimension makes sense with any of @tt{for-run}, @tt{for-expand}, or
@tt{for-label}.}
@p{As far as I can tell, multiple binding spaces do correspond to a kind of
suffix naming convention. That is, when the @tt{lexer}, @tt{require},
or typed-Scheme expander looks up a binding in a particular space, it
could just as well add a space-specific suffix to the name.}
@p{The only advantage of a distinct binding space, then, seems to be in
separating the "suffix" from the base name (so that the suffix can't be
used accidentally in the wrong context). That doesn't seem like enough
of an advantage to build into the macro/module core.}
@p{Granted, adding a suffix is a kind of hack. Also, we don't try to
simulate modules via module-specific suffixes, even though the
namespace facet of a module really is just a kind of suffix. But
modules do more than avoid name collisions, and suffixes don't fulfill
the other roles.}
@p{Another bit of potential complexity is in local bindings. We could have
@tt{let}, @tt{let-syntax}, and @tt{define} variants that combine an
identifier with a binding space. For the general case, we could have a
variant of @tt{letrec-values+syntaxes} where the space for each binding
is specified independently.}
@h2{Whether to Use Separate Binding Spaces}
@p{From everything I've considered so far, building separate spaces into
the core looks like too much complexity for too little pay-off.
Suffixes should work fine, if we want the effect of separate spaces.}
@p{With that in mind, I'm still undecided on whether to use separate
binding spaces at all (as simulated via suffixes). Since there doesn't
seem to be anything deeply new about separate binding spaces, I can't
help thinking that they aren't inherently "right". A single binding
space is simpler for both programmers and documentation.}
@p{We also have cases where a separate binding space won't work, because
expressions and non-expressions are mixed. The most prominent example
is are forms like @tt{public} and @tt{init} in @tt{class}, which are
mixed with definitions and expressions. For such cases, we will
continue to struggle with name collisions.}
@p{Then again, if the @tt{class} form were designed in a language that
encouraged separate spaces, maybe it would have a different syntax.
It's tempting to start a deeper re-design to see the full effect of
multiple binding spaces. But not that tempting.}
@i{Matthew Flatt@br{}2007-10-15}))
| false |
685487fd830814c399f763cec11e6817f6dd1a82
|
2b651b50bca4b7a67f86dfc92e17d34d0fe324e6
|
/contrib/srfi/195.scm
|
b83c591ef2e19a860d586af351f51e782e87329b
|
[] |
no_license
|
mnieper/srfi-210
|
20326307fcb39e0e05d63e634e4a2e7e14c414e1
|
f9feb724862f8e6988abe758dc862663f6ed043c
|
refs/heads/master
| 2023-03-05T07:29:15.868430 | 2021-02-12T09:39:12 | 2021-02-12T09:39:12 | 291,443,404 | 0 | 1 | null | 2020-08-30T09:54:31 | 2020-08-30T09:54:31 | null |
UTF-8
|
Scheme
| false | false | 1,519 |
scm
|
195.scm
|
;; Copyright (C) Marc Nieper-Wißkirchen (2020). All Rights Reserved.
;; Permission is hereby granted, free of charge, to any person
;; obtaining a copy of this software and associated documentation
;; files (the "Software"), to deal in the Software without
;; restriction, including without limitation the rights to use, copy,
;; modify, merge, publish, distribute, sublicense, and/or sell copies
;; of the Software, and to permit persons to whom the Software is
;; furnished to do so, subject to the following conditions:
;; The above copyright notice and this permission notice shall be
;; included in all copies or substantial portions of the Software.
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;; SOFTWARE.
(define-record-type <box>
(make-box v*)
box?
(v* unbox* set-box*!))
(define (box . v*)
(make-box v*))
(define (unbox b)
(apply values (unbox* b)))
(define (set-box! b . v*)
(set-box*! b v*))
(define (box-arity b)
(length (unbox* b)))
(define (unbox-value b i)
(list-ref (unbox* b) i))
(define (set-box-value! b i obj)
(list-set! (unbox* b) i obj))
| false |
ecfd0a1928855fd83579ece83994cf08895b3827
|
63a1f38e64b0604377fbfa0d10d48545c609cc86
|
/icfp09-atotcaia/atotcaia-tests.ss
|
e1ab1b09efd7359dfb5972603fb3d4f87a3d66c8
|
[] |
no_license
|
jeapostrophe/redex
|
d02b96b441f27e3afa1ef92726741ec026160944
|
8e5810e452878a4ab5153d19725cfc4cf2b0bf46
|
refs/heads/master
| 2016-09-06T00:55:02.265152 | 2013-10-31T01:24:11 | 2013-10-31T01:24:11 | 618,062 | 2 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,783 |
ss
|
atotcaia-tests.ss
|
#lang scheme
(require redex
tests/eli-tester
"atotcaia-search.ss")
(test
(term (Γ/append · ((· u : (var h)) (var B) : ((var m) → (var a)))))
; pg 330 (right bottom)
(true?
(term (coerce ((· ftoi : Float → Int)
((· f : (Int → Int)) x : Float)
⊢ b b
(f x)
~~>
(f (ftoi x))
:
Int))))
; pg 331 (left top)
; XXX The paper incorrectly synthesizes these environments on the left from the previous ones
(true?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
((plus x) x)
~~>
(((ptoi plus) (ftoi x)) (ftoi x))
:
Int))))
(true?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
((plus x) x)
~~>
(((ptof plus) x) x)
:
Float))))
; With casts
(true?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
(((plus x) x) : Int)
~~>
(((ptoi plus) (ftoi x)) (ftoi x))
:
Int))))
(true?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
(((plus x) x) : Float)
~~>
(((ptof plus) x) x)
:
Float))))
; Casts rule out the other
(false?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
(((plus x) x) : Float)
~~>
(((ptoi plus) (ftoi x)) (ftoi x))
:
Int))))
(false?
(term (coerce ((((· ptof : P → (Float → (Float → Float)))
ptoi : P → (Int → (Int → Int)))
ftoi : Float → Int)
(((· plus : P) f : (Int → Int)) x : Float)
⊢ b b
(((plus x) x) : Int)
~~>
(((ptof plus) x) x)
:
Float))))
; pg 333
(true?
(term
(generate (((· f : A → B) g : B → C)
⊢
A
<I r
C
~~>
(((id C) ◦ g) ◦ f)))))
; pg 333, Figure 4
(true?
(term
(coerce (((((· conX : X → Int) absX : Int → X)
conY : Y → X) absY : X → Y)
(((· one : Int) y : Y) f : (X → (X → X)))
⊢ r r
((f y) one)
~~>
((f (((id X) ◦ conY) y))
(((id X) ◦ absX) one))
:
X))))
)
; pg 336, Figure 7
(define Fig7-Σ
(term
((((((((· Bo : Bool → Dyn) Bn : Dyn → Bool)
I : Int → Dyn) In : Dyn → Int)
F : (Dyn → Dyn) → Dyn) Fn : Dyn → (Dyn → Dyn))
P : (Dyn × Dyn) → Dyn) Pn : Dyn → (Dyn × Dyn))))
; XXX Both wrong in the paper
(test
(true? (term (coerce (,Fig7-Σ
(· one : Int)
⊢ r s
((λ x : Dyn x) one)
~~>
((λ x : Dyn x) (((id Dyn) ◦ I) one))
:
Dyn))))
(true? (term (coerce (,Fig7-Σ
((· one : Int) true : Bool)
⊢ r s
(one true)
~~>
(((((id (Dyn → Dyn)) ◦ Fn) ◦ I) one) (((id Dyn) ◦ Bo) true))
:
Dyn)))))
; I had to enumerate to figure out the right one:
#;(for*/list ([one (in-list (list #t #f))]
[Fn (in-list (list #t #f))]
[I (in-list (list #t #f))]
[Bo (in-list (list #t #f))])
(define (insert do-it t x)
(if do-it
`((id ,t) ◦ ,x)
x))
(list one Fn I Bo
(true? (term (coerce (,Fig7-Σ
((· one : Int) true : Bool)
⊢ r s
(one true)
~~>
((,(insert one '(Dyn → Dyn) (term (,(insert Fn '(Dyn → Dyn) 'Fn) ◦ ,(insert I 'Dyn 'I)))) one) (,(insert Bo 'Dyn 'Bo) true))
:
Dyn))))))
(local [(define Σ
(term ((((· conX : X → Int) absX : Int → X)
conY : Y → X) absY : X → Y)))]
(test
(Reachable Σ 'X 'Y)
(Reachable Σ 'X 'X)
(Reachable Σ 'X 'Int)
(Reachable Σ 'Y 'Y)
(Reachable Σ 'Y 'X)
(Reachable Σ 'Y 'Int)
(Reachable Σ 'Int 'Y)
(Reachable Σ 'Int 'X)
(Reachable Σ 'Int 'Int)))
(test
(BaseCoercions (term ·))
(BaseCoercions (term (· x : X → Y)))
(BaseCoercions (term (· x : X → (Y → Z))))
(BaseCoercions (term (· x : (X → Y) → Z))) => #f
(BaseCoercions (term ((· x : X → Y) x : X → Y)))
(BaseCoercions (term ((· x : X → Y) x : X → (Y → Z))))
(BaseCoercions (term ((· x : X → Y) x : (X → Y) → Z))) => #f
(BaseCoercions (term ((· x : (X → Y) → Z) x : X → Y))) => #f
(BaseCoercions (term ((· x : (X → Y) → Z) x : X → (Y → Z)))) => #f
(BaseCoercions (term ((· x : (X → Y) → Z) x : (X → Y) → Z))) => #f)
; pg 337 (poorly specified in paper)
(define p337-ex
(term
(coerce (((· lazy : (forall (a) ((Unit → a) → (Lazy a))))
force : (forall (a) ((Lazy a) → a)))
((· + : (Int → (Int → Int)))
one : Int)
⊢ p s ;XXX q?
((λ y : (Lazy Int) ((+ y) one)) (λ x : Unit e))
~~>
((λ y : (Lazy Int) ((+ ((inst force (Int)) y)) one)) (lazy (λ x : Unit e)))
:
Int))))
(test
(true? p337-ex))
#;(step-it p337-ex)
| false |
e9137bded51a405a698dab283dd5cedca5aef3ba
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System.Data/microsoft/sql-server/server/sql-facet-attribute.sls
|
884c569a078aa9dbc6d33fff9dc58ccf67a2eb3c
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,826 |
sls
|
sql-facet-attribute.sls
|
(library (microsoft sql-server server sql-facet-attribute)
(export new
is?
sql-facet-attribute?
is-fixed-length?-get
is-fixed-length?-set!
is-fixed-length?-update!
is-nullable?-get
is-nullable?-set!
is-nullable?-update!
max-size-get
max-size-set!
max-size-update!
precision-get
precision-set!
precision-update!
scale-get
scale-set!
scale-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
Microsoft.SqlServer.Server.SqlFacetAttribute
a
...)))))
(define (is? a)
(clr-is Microsoft.SqlServer.Server.SqlFacetAttribute a))
(define (sql-facet-attribute? a)
(clr-is Microsoft.SqlServer.Server.SqlFacetAttribute a))
(define-field-port
is-fixed-length?-get
is-fixed-length?-set!
is-fixed-length?-update!
(property:)
Microsoft.SqlServer.Server.SqlFacetAttribute
IsFixedLength
System.Boolean)
(define-field-port
is-nullable?-get
is-nullable?-set!
is-nullable?-update!
(property:)
Microsoft.SqlServer.Server.SqlFacetAttribute
IsNullable
System.Boolean)
(define-field-port
max-size-get
max-size-set!
max-size-update!
(property:)
Microsoft.SqlServer.Server.SqlFacetAttribute
MaxSize
System.Int32)
(define-field-port
precision-get
precision-set!
precision-update!
(property:)
Microsoft.SqlServer.Server.SqlFacetAttribute
Precision
System.Int32)
(define-field-port
scale-get
scale-set!
scale-update!
(property:)
Microsoft.SqlServer.Server.SqlFacetAttribute
Scale
System.Int32))
| true |
3bfecaae4a7d41e1328b3c46855f4a70a2b01e63
|
fb245c4f894872965bd323ae3aa778fe8ff578ac
|
/macros/loop-check.scm
|
9339c0a8a50bc831cd145825df09e47857736551
|
[
"MIT"
] |
permissive
|
HugoNikanor/guile-lib
|
d95bd5040e2128898cc7637b338c56cbd55bf179
|
adf59754a6409638e4fc41bdb78c296a6d6b4263
|
refs/heads/master
| 2020-04-06T07:53:20.575987 | 2018-03-12T12:21:13 | 2018-03-12T12:21:13 | 65,499,978 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 752 |
scm
|
loop-check.scm
|
(define-module (macros loop-check)
#:export (loop-check))
(read-enable 'hungry-eol-escapes)
(define-macro (loop-check declaration until . body)
"Set value specified in declaration and loop until \
\nthe until clause is true. When it's true return \
\nthe last value \
\n\
\n(loop-check \
\n (line (read-line)) \
\n (eof-object? line) \
\n (displayln line)) \
\n=> #<eof>"
(let ((loop (gensym))
(return (gensym))
(symb (car declaration)))
`(call/cc (lambda (,return)
(let ,loop ()
(let (,declaration)
(if ,until
(,return ,symb)
(begin ,@body
(,loop)))))))))
| false |
ebb031dfec7636ccd2fca9d95fc33c8a807a51c1
|
ae76253c0b7fadf8065777111d3aa6b57383d01b
|
/chap4/exec-4.59-data.ss
|
2081941d35d6951ee8ceedfd108fb2bcb32904ca
|
[] |
no_license
|
cacaegg/sicp-solution
|
176995237ad1feac39355f0684ee660f693b7989
|
5bc7df644c4634adc06355eefa1637c303cf6b9e
|
refs/heads/master
| 2021-01-23T12:25:25.380872 | 2014-04-06T09:35:15 | 2014-04-06T09:35:15 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 77 |
ss
|
exec-4.59-data.ss
|
(meeting ?all-div (Friday ?all-time))
(meeting-time (Hacker Alyssa P) ?all)
| false |
4b091f5527611cb304d3b8bc3c00695594d27d12
|
665da87f9fefd8678b0635e31df3f3ff28a1d48c
|
/examples/hello-library/hello.scm
|
b5ef2ad50ce5043fe598ce4542b04da873d7a125
|
[
"MIT"
] |
permissive
|
justinethier/cyclone
|
eeb782c20a38f916138ac9a988dc53817eb56e79
|
cc24c6be6d2b7cc16d5e0ee91f0823d7a90a3273
|
refs/heads/master
| 2023-08-30T15:30:09.209833 | 2023-08-22T02:11:59 | 2023-08-22T02:11:59 | 31,150,535 | 862 | 64 |
MIT
| 2023-03-04T15:15:37 | 2015-02-22T03:08:21 |
Scheme
|
UTF-8
|
Scheme
| false | false | 377 |
scm
|
hello.scm
|
; TODO: just adding temporarily until import is supported.
; idea is to try and see how the C code needs to change to
(import (scheme base)
(scheme write)
(libs lib1)
;(rename (prefix (libs lib1) test-))
)
(write "hello")
(newline)
(write lib1-test-renamed)
(newline)
(write (lib1-hello))
(newline)
(write "world")
(newline)
| false |
1fe5992fa2efdfd7404f5f1e133f006255a0cd40
|
7301b8e6fbd4ac510d5e8cb1a3dfe5be61762107
|
/ex-4.62.scm
|
a19bb57fa02c845b4b4a9fb409b567e7e88e34e2
|
[] |
no_license
|
jiakai0419/sicp-1
|
75ec0c6c8fe39038d6f2f3c4c6dd647a39be6216
|
974391622443c07259ea13ec0c19b80ac04b2760
|
refs/heads/master
| 2021-01-12T02:48:12.327718 | 2017-01-11T12:54:38 | 2017-01-11T12:54:38 | 78,108,302 | 0 | 0 | null | 2017-01-05T11:44:44 | 2017-01-05T11:44:44 | null |
UTF-8
|
Scheme
| false | false | 837 |
scm
|
ex-4.62.scm
|
;;; Exercise 4.62. Define rules to implement the last-pair operation of
;;; exercise 2.17, which returns a list containing the last element of
;;; a nonempty list. Check your rules on queries such as (last-pair (3) ?x),
;;; (last-pair (1 2 3) ?x), and (last-pair (2 ?x) (3)). Do your rules work
;;; correctly on queries such as (last-pair ?x (3)) ?
(load "./sec-4.4.4.scm")
(load "./sec-4.4.1-sample-db.scm")
(query-driver-loop-for-script '(
(assert! (rule (last-pair ?x ?x)
(same ?x (?e . ()))))
(assert! (rule (last-pair (?z . ?y) ?x)
(last-pair ?y ?x)))
(last-pair (3) ?x)
; ==> (last-pair (3) (3))
(last-pair (1 2 3) ?x)
; ==> (last-pair (1 2 3) (3))
(last-pair (2 ?x) (3))
; ==> (last-pair (2 3) (3))
; (last-pair ?x (3))
; ==> ...? There are infinite instances.
))
| false |
e8c80f4a77dbdf53d67e94667385797d3701e34d
|
f4cf5bf3fb3c06b127dda5b5d479c74cecec9ce9
|
/Sources/LispKit/Resources/Libraries/srfi/162.sld
|
4a7a5343fa905d81d3e634498eff9ea03d70bfad
|
[
"Apache-2.0"
] |
permissive
|
objecthub/swift-lispkit
|
62b907d35fe4f20ecbe022da70075b70a1d86881
|
90d78a4de3a20447db7fc33bdbeb544efea05dda
|
refs/heads/master
| 2023-08-16T21:09:24.735239 | 2023-08-12T21:37:39 | 2023-08-12T21:37:39 | 57,930,217 | 356 | 17 |
Apache-2.0
| 2023-06-04T12:11:51 | 2016-05-03T00:37:22 |
Scheme
|
UTF-8
|
Scheme
| false | false | 3,111 |
sld
|
162.sld
|
;;; SRFI 162
;;; Comparators
;;;
;;; This SRFI extends SRFI 128. It provides comparators, which bundle a type test predicate,
;;; an equality predicate, an ordering predicate, and a hash function (the last two are optional)
;;; into a single Scheme object. By packaging these procedures together, they can be treated as
;;; a single item for use in the implementation of data structures.
;;;
;;; Copyright © 2018 John Cowan. All Rights Reserved.
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use,
;;; copy, modify, merge, publish, distribute, sublicense, and/or
;;; sell copies of the Software, and to permit persons to whom the
;;; Software is furnished to do so, subject to the following
;;; conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
;;; OTHER DEALINGS IN THE SOFTWARE.
;;;
;;; LispKit Port:
;;; Copyright © 2020 Matthias Zenger. All rights reserved.
(define-library (srfi 162)
;; SRFI 128 exports
(export comparator?
comparator-ordered?
comparator-hashable?
make-comparator
make-pair-comparator
make-list-comparator
make-vector-comparator
make-eq-comparator
make-eqv-comparator
make-equal-comparator
boolean-hash
char-hash
char-ci-hash
string-hash
string-ci-hash
symbol-hash
number-hash
make-default-comparator
default-hash
comparator-register-default!
comparator-type-test-predicate
comparator-equality-predicate
comparator-ordering-predicate
comparator-hash-function
comparator-test-type
comparator-check-type
comparator-hash
hash-bound
hash-salt
=?
<?
>?
<=?
>=?
comparator-if<=>)
;; SRFI 162 exports
(export comparator-max
comparator-min
comparator-max-in-list
comparator-min-in-list
default-comparator
boolean-comparator
real-comparator
char-comparator
char-ci-comparator
string-comparator
string-ci-comparator
list-comparator
vector-comparator
eq-comparator
eqv-comparator
equal-comparator)
(import (srfi 128))
)
| false |
ea90917f3582647ffc6fa5f3adb1ec323f92f231
|
648776d3a0d9a8ca036acaf6f2f7a60dcdb45877
|
/queries/sql/highlights.scm
|
d5c2c64f0781713e60e3fd404fe56291ddc70cb6
|
[
"Apache-2.0"
] |
permissive
|
nvim-treesitter/nvim-treesitter
|
4c3c55cbe6ff73debcfaecb9b7a0d42d984be3e6
|
f8c2825220bff70919b527ee68fe44e7b1dae4b2
|
refs/heads/master
| 2023-08-31T20:04:23.790698 | 2023-08-31T09:28:16 | 2023-08-31T18:19:23 | 256,786,531 | 7,890 | 980 |
Apache-2.0
| 2023-09-14T18:07:03 | 2020-04-18T15:24:10 |
Scheme
|
UTF-8
|
Scheme
| false | false | 6,561 |
scm
|
highlights.scm
|
[
(keyword_gist)
(keyword_btree)
(keyword_hash)
(keyword_spgist)
(keyword_gin)
(keyword_brin)
(keyword_array)
] @function.call
(object_reference
name: (identifier) @type)
(invocation
(object_reference
name: (identifier) @function.call
parameter: [(field)]? @parameter))
(relation
alias: (identifier) @variable)
(field
name: (identifier) @field)
(term
alias: (identifier) @variable)
((term
value: (cast
name: (keyword_cast) @function.call
parameter: [(literal)]?)))
(literal) @string
(comment) @comment @spell
(marginalia) @comment
((literal) @number
(#lua-match? @number "^%d+$"))
((literal) @float
(#lua-match? @float "^[-]?%d*\.%d*$"))
(parameter) @parameter
[
(keyword_true)
(keyword_false)
] @boolean
[
(keyword_asc)
(keyword_desc)
(keyword_terminated)
(keyword_escaped)
(keyword_unsigned)
(keyword_nulls)
(keyword_last)
(keyword_delimited)
(keyword_replication)
(keyword_auto_increment)
(keyword_default)
(keyword_collate)
(keyword_concurrently)
(keyword_engine)
(keyword_always)
(keyword_generated)
(keyword_preceding)
(keyword_following)
(keyword_first)
(keyword_current_timestamp)
(keyword_immutable)
(keyword_atomic)
(keyword_parallel)
(keyword_leakproof)
(keyword_safe)
(keyword_cost)
(keyword_strict)
(keyword_matched)
(keyword_encrypted)
(keyword_valid)
(keyword_admin)
(keyword_user)
(keyword_until)
(keyword_connection)
(keyword_cycle)
(keyword_increment)
(keyword_minvalue)
(keyword_maxvalue)
(keyword_none)
(keyword_owned)
(keyword_verbose)
(keyword_authorization)
] @attribute
[
(keyword_materialized)
(keyword_tablespace)
(keyword_recursive)
(keyword_temp)
(keyword_temporary)
(keyword_unlogged)
(keyword_logged)
(keyword_external)
(keyword_parquet)
(keyword_csv)
(keyword_rcfile)
(keyword_textfile)
(keyword_orc)
(keyword_avro)
(keyword_jsonfile)
(keyword_sequencefile)
(keyword_volatile)
] @storageclass
[
(keyword_case)
(keyword_when)
(keyword_then)
(keyword_else)
] @conditional
[
(keyword_select)
(keyword_from)
(keyword_where)
(keyword_index)
(keyword_join)
(keyword_primary)
(keyword_delete)
(keyword_create)
(keyword_insert)
(keyword_merge)
(keyword_truncate)
(keyword_explain)
(keyword_distinct)
(keyword_replace)
(keyword_update)
(keyword_into)
(keyword_overwrite)
(keyword_values)
(keyword_set)
(keyword_left)
(keyword_right)
(keyword_outer)
(keyword_inner)
(keyword_full)
(keyword_order)
(keyword_partition)
(keyword_group)
(keyword_with)
(keyword_as)
(keyword_having)
(keyword_limit)
(keyword_offset)
(keyword_table)
(keyword_tables)
(keyword_key)
(keyword_references)
(keyword_foreign)
(keyword_constraint)
(keyword_force)
(keyword_use)
(keyword_for)
(keyword_if)
(keyword_exists)
(keyword_max)
(keyword_min)
(keyword_avg)
(keyword_column)
(keyword_columns)
(keyword_cross)
(keyword_lateral)
(keyword_alter)
(keyword_drop)
(keyword_add)
(keyword_view)
(keyword_database)
(keyword_role)
(keyword_group)
(keyword_sequence)
(keyword_end)
(keyword_is)
(keyword_using)
(keyword_between)
(keyword_window)
(keyword_no)
(keyword_data)
(keyword_type)
(keyword_value)
(keyword_attribute)
(keyword_rename)
(keyword_to)
(keyword_schema)
(keyword_owner)
(keyword_union)
(keyword_all)
(keyword_any)
(keyword_some)
(keyword_except)
(keyword_intersect)
(keyword_returning)
(keyword_begin)
(keyword_commit)
(keyword_rollback)
(keyword_transaction)
(keyword_only)
(keyword_like)
(keyword_similar)
(keyword_over)
(keyword_change)
(keyword_modify)
(keyword_after)
(keyword_before)
(keyword_range)
(keyword_rows)
(keyword_groups)
(keyword_exclude)
(keyword_current)
(keyword_ties)
(keyword_others)
(keyword_preserve)
(keyword_zerofill)
(keyword_format)
(keyword_fields)
(keyword_row)
(keyword_sort)
(keyword_compute)
(keyword_comment)
(keyword_location)
(keyword_cached)
(keyword_uncached)
(keyword_lines)
(keyword_stored)
(keyword_partitioned)
(keyword_analyze)
(keyword_rewrite)
(keyword_optimize)
(keyword_vacuum)
(keyword_cache)
(keyword_language)
(keyword_sql)
(keyword_called)
(keyword_conflict)
(keyword_declare)
(keyword_filter)
(keyword_function)
(keyword_input)
(keyword_name)
(keyword_oid)
(keyword_options)
(keyword_plpgsql)
(keyword_precision)
(keyword_regclass)
(keyword_regnamespace)
(keyword_regproc)
(keyword_regtype)
(keyword_restricted)
(keyword_return)
(keyword_returns)
(keyword_separator)
(keyword_setof)
(keyword_stable)
(keyword_support)
(keyword_tblproperties)
(keyword_trigger)
(keyword_unsafe)
(keyword_start)
(keyword_restart)
] @keyword
[
(keyword_restrict)
(keyword_unbounded)
(keyword_unique)
(keyword_cascade)
(keyword_delayed)
(keyword_high_priority)
(keyword_low_priority)
(keyword_ignore)
(keyword_nothing)
(keyword_check)
(keyword_option)
(keyword_local)
(keyword_cascaded)
(keyword_wait)
(keyword_nowait)
(keyword_metadata)
(keyword_incremental)
(keyword_bin_pack)
(keyword_noscan)
(keyword_stats)
(keyword_statistics)
] @type.qualifier
[
(keyword_int)
(keyword_null)
(keyword_boolean)
(keyword_binary)
(keyword_varbinary)
(keyword_image)
(keyword_bit)
(keyword_inet)
(keyword_character)
(keyword_smallserial)
(keyword_serial)
(keyword_bigserial)
(keyword_smallint)
(keyword_mediumint)
(keyword_bigint)
(keyword_tinyint)
(keyword_decimal)
(keyword_float)
(keyword_double)
(keyword_numeric)
(keyword_real)
(double)
(keyword_money)
(keyword_smallmoney)
(keyword_char)
(keyword_nchar)
(keyword_varchar)
(keyword_nvarchar)
(keyword_varying)
(keyword_text)
(keyword_string)
(keyword_uuid)
(keyword_json)
(keyword_jsonb)
(keyword_xml)
(keyword_bytea)
(keyword_enum)
(keyword_date)
(keyword_datetime)
(keyword_time)
(keyword_datetime2)
(keyword_datetimeoffset)
(keyword_smalldatetime)
(keyword_timestamp)
(keyword_timestamptz)
(keyword_geometry)
(keyword_geography)
(keyword_box2d)
(keyword_box3d)
(keyword_interval)
] @type.builtin
[
(keyword_in)
(keyword_and)
(keyword_or)
(keyword_not)
(keyword_by)
(keyword_on)
(keyword_do)
] @keyword.operator
[
"+"
"-"
"*"
"/"
"%"
"^"
":="
"="
"<"
"<="
"!="
">="
">"
"<>"
"->"
"->>"
"#>"
"#>>"
] @operator
[
"("
")"
] @punctuation.bracket
[
";"
","
"."
] @punctuation.delimiter
| false |
0d7b3cfc98b6e8da5c101e7bfe55a0f6d8a825ba
|
486d827459ba1114134654055e2ac11d3c5ab817
|
/LearningAndroid-chapter9/src/com/zeroxab/learningandroid/yamba/Yamba.scm
|
85daa546daaeb3f3d5cad1376ba20fb671566c2e
|
[] |
no_license
|
devehe/android-kawa
|
2a38e1e4a64f07a86072e4cf9815e00820c8c269
|
3e7b5dc46bdda436e64f70e71f37a0a7e74e7e5f
|
refs/heads/master
| 2020-12-28T17:31:55.745193 | 2013-09-10T21:21:41 | 2013-09-10T21:21:41 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 13,550 |
scm
|
Yamba.scm
|
(require 'android-defs)
(require 'srfi-1)
(require 'syntax-utils)
(require <collections_utils>)
(define-namespace Log "class:android.util.Log")
;; from kawa/testsuite/classes1.scm
(define-syntax (import-class form)
(syntax-case form ()
((import-class fqcn)
(let* ((cls :: java.lang.Class (eval (syntax fqcn)))
(name (string->symbol (java.lang.Class:getSimpleName cls))))
#`(define-alias #,(datum->syntax-object form name) fqcn)))))
(define-alias Arrays java.util.Arrays)
(define-alias Math java.lang.Math)
(define-alias InterruptedException java.lang.InterruptedException)
(define-alias Thread java.lang.Thread)
(define-alias Application android.app.Application)
(define-alias Activity android.app.Activity)
(define-alias Service android.app.Service)
(define-alias Bitmap android.graphics.Bitmap)
(define-alias Canvas android.graphics.Canvas)
(define-alias Color android.graphics.Color)
(define-alias Drawable android.graphics.drawable.Drawable)
(define-alias Context android.content.Context)
(define-alias Intent android.content.Intent)
(define-alias Resources android.content.res.Resources)
(define-alias SharedPreferences android.content.SharedPreferences)
(define-alias ContentValues android.content.ContentValues)
(define-alias Handler android.os.Handler)
(define-alias Bundle android.os.Bundle)
(define-alias IBinder android.os.IBinder)
(define-alias KeyEvent android.view.KeyEvent)
(define-alias OnClickListener android.view.View$OnClickListener)
(define-alias SurfaceHolder android.view.SurfaceHolder)
(define-alias Menu android.view.Menu)
(define-alias MenuItem android.view.MenuItem)
(define-alias Toast android.widget.Toast)
(define-alias Editable android.text.Editable)
(define-alias TextWatcher android.text.TextWatcher)
(define-alias PreferenceActivity android.preference.PreferenceActivity)
(define-alias PreferenceManager android.preference.PreferenceManager)
(define-alias BaseColumns android.provider.BaseColumns)
(define-alias Cursor android.database.Cursor)
(define-alias SQLiteDatabase android.database.sqlite.SQLiteDatabase)
(define-alias SQLiteOpenHelper android.database.sqlite.SQLiteOpenHelper)
(define-alias FVector gnu.lists.FVector)
(define-alias R com.zeroxab.learningandroid.yamba.R)
(define-alias Twitter winterwell.jtwitter.Twitter)
(define update-delay 10000) ;; 10 seconds
(define-syntax async-task
(lambda (x)
;; TODO should add in the ability to bind (this) at the callsite to
;; (this-parent) so that I don't need an ugly let
(syntax-case x ()
((async-task paramsT progressT resultT . r)
(letrec
((process
(lambda (form)
(syntax-case form (background cancel post pre progress publish-progress)
(((background name stmt ...) . rest)
;; FIXME using object here instead of object1 seems to
;; change the object macro at the toplevel in the
;; interpreter, this looks like a bug
(cons #`((doInBackground (object1 ::Object[])) (@java.lang.Override) ::Object
(as resultT (let ((name (gnu.lists.FVector[paramsT] object1))) stmt ...)))
(process #`rest)))
(((cancel name stmt ...) . rest)
(cons #`((onCancelled (object1 ::Object)) (@java.lang.Override) ::void
(let ((name (as resultT object1))) stmt ...))
(process #`rest)))
(((post name stmt ...) . rest)
(cons #`((onPostExecute (object1 ::Object)) (@java.lang.Override) ::void
(let ((name (as resultT object1))) stmt ...))
(process #`rest)))
(((pre stmt ...) . rest)
(cons #`(onPreExecute (@java.lang.Override) ::void stmt ...)
(process #`rest)))
(((progress stmt ...) . rest)
(cons #`((onProgressUpdate (object1 ::Object[])) (@java.lang.Override) ::void
(let ((name (gnu.lists.FVector[progressT] object1)))
stmt ...))
(process #`rest)))
(((publish-progress stmt ...) . rest)
(cons #`((publishProgress (object1 ::Object[])) (@java.lang.Override) ::void
(let ((name (gnu.lists.FVector[progressT] object1)))
stmt ...))
(process #`rest)))
(() '())))))
#`(object (android.os.AsyncTask) #,@(process #`r)))))))
(define-syntax simple-thread
(lambda (x)
;; TODO should add in the ability to bind (this) at the callsite to
;; (this-parent) so that I don't need an ugly let
(syntax-case x ()
((simple-thread stmts ...)
#`(as Thread (object (Thread) ((run) ::void
stmts ...)))))))
(define-simple-class PrefActivity (PreferenceActivity)
((onCreate (savedInstanceState ::Bundle))
(invoke-special android.app.Activity (this) 'onCreate savedInstanceState)
(addPreferencesFromResource R$xml:prefs)))
(define-simple-class YambaApplication (Application)
(twitter ::Twitter)
(preferences ::SharedPreferences)
(service-running? ::boolean)
(status-data ::StatusData)
((onCreate)
(invoke-special android.app.Application (this) 'onCreate)
(set! preferences (PreferenceManager:getDefaultSharedPreferences (this)))
(set! status-data (make StatusData (this)))
(preferences:registerOnSharedPreferenceChangeListener
(lambda ((preferences ::SharedPreferences) (key ::String))
(set! twitter #!null))))
((onTerminate)
(invoke-special android.app.Application (this) 'onTerminate))
((get-twitter) ::Twitter
(synchronized
(this)
(when (equal? twitter #!null)
(set! twitter (Twitter:new (preferences:getString "username" "student")
(preferences:getString "password" "password")))
(twitter:setAPIRootUrl (preferences:getString "apiRoot" "http://yamba.marakana.com/api"))))
twitter)
((get-status-data) ::StatusData
status-data)
((fetch-status-updates) ::int
(Log:d "Yamba" "Fetching status")
(let ((twitter (get-twitter)))
(if (equal? twitter #!null)
(begin (Log:e "Yamba" "Twitter not initialized!") 0)
(try-catch
(let* ((latest-status-at
::long
((get-status-data):get-latest-status-created-at-time))
(nr
(count
(lambda (a) (equal? #t a))
(->list
(better-map
(lambda (status ::<winterwell.jtwitter.Status>)
(let* ((values (make ContentValues))
(created-at
(java.lang.Long ((status:getCreatedAt):getTime))))
(values:clear)
(values:put StatusData:C_ID status:id)
(values:put StatusData:C_CREATED_AT created-at)
;; (values:put StatusData:C_SOURCE status:source)
(values:put StatusData:C_TEXT status:text)
(values:put StatusData:C_USER (status:getUser):name)
((get-status-data):insert-or-ignore values)
(< latest-status-at created-at)))
(twitter:getFriendsTimeline))))))
(Log:d "Yamba added status update" nr)
nr)
(e android.database.SQLException ;; java.lang.RuntimeException
(Log:e "Yamba-UpdaterService" e)
(Log:e "Yamba-UpdaterService" "Runtime!")
0))))))
(define-simple-class StatusActivity (Activity <android.text.TextWatcher>)
(edit-text ::EditText)
(update-button ::Button)
(text-count ::TextView)
((onCreate (savedInstanceState ::Bundle))
(invoke-special android.app.Activity (this) 'onCreate savedInstanceState)
(setContentView R$layout:status)
(set! edit-text (findViewById R$id:editText))
(set! update-button (findViewById R$id:buttonUpdate))
(update-button:setOnClickListener
(lambda ((view ::View))
;; FIXME this is nasty
(let* ((activity-this (this)))
(*:execute
(async-task
String int String
(background statuses
(try-catch
(begin (((as YambaApplication (getApplication)):get-twitter):setStatus (statuses 0))
(statuses 0))
(e winterwell.jtwitter.TwitterException
(Log:e "Yamba-StatusActivity" "Failed to set twitter status!")
(e:printStackTrace)
"Ooops, failed to post status!")))
(progress values #!null)
(post result ((Toast:makeText activity-this (as <String> result) Toast:LENGTH_LONG):show)))
((edit-text:getText):toString))
(Log:d "Yamba-StatusActivity" "Clicked!"))))
(set! text-count (findViewById R$id:textCount))
(text-count:setText (140:toString))
(text-count:setTextColor Color:GREEN)
(edit-text:addTextChangedListener (this)))
((afterTextChanged (status-text ::Editable))
(let ((count (- 140 (status-text:length))))
(text-count:setText (format #f "~a" count))
(text-count:setTextColor (cond ((< count 0) Color:RED)
((< count 10) Color:YELLOW)
(else Color:GREEN)))))
((beforeTextChanged sequence start count after) #f)
((onTextChanged sequence start before count) #f)
((onCreateOptionsMenu (menu ::Menu))
((getMenuInflater):inflate R$menu:menu menu)
#t)
((onOptionsItemSelected (item ::MenuItem))
(cond ((equal? (item:getItemId) R$id:itemPrefs)
(startActivity (make <android.content.Intent> (this) PrefActivity)))
((equal? (item:getItemId) R$id:itemServiceStart)
(startService (make <android.content.Intent> (this) UpdaterService)))
((equal? (item:getItemId) R$id:itemServiceStop)
(stopService (make <android.content.Intent> (this) UpdaterService)))
(else #f))
#t))
(define-simple-class UpdaterService (Service)
(updater ::Thread)
(running? ::boolean)
((onBind (intent ::Intent)) #!null)
((onCreate) (invoke-special android.app.Service (this) 'onCreate)
(Log:d "Yamba-UpdaterService" "Created")
(set! updater
(simple-thread
(try-catch
(let loop ()
(when running?
(Log:d "Yamba-UpdaterService" "Running")
(when (> ((as YambaApplication (getApplication)):fetch-status-updates) 0)
(Log:d "UpdateService" "New status"))
(Thread:sleep update-delay)
(loop)))
(e java.lang.InterruptedException
(Log:e "Yamba-UpdaterService" e)
(Log:e "Yamba-UpdaterService" "Failed!")
#f)))))
((onStartCommand (intent ::Intent) (flags ::int) (startId ::int))
(invoke-special android.app.Service (this) 'onStartCommand intent flags startId)
(unless running?
(set! (as YambaApplication (getApplication)):service-running? #t)
(set! running? #t)
(*:start updater)
(Log:d "Yamba-UpdaterService" "Started"))
Service:START_STICKY)
((onDestroy)
(set! (as YambaApplication (getApplication)):service-running? #f)
(when running?
(set! running? #f)
(*:interrupt updater)
(Log:d "Yamba-UpdaterService" "Destroyed"))))
(define-simple-class dbHelper (SQLiteOpenHelper)
((*init* (context_ ::Context))
(invoke-special android.database.sqlite.SQLiteOpenHelper
(this) '*init* context_ StatusData:DATABASE
#!null StatusData:VERSION))
((onCreate (db ::SQLiteDatabase))
(let ((sql (string-append "create table "
StatusData:TABLE " ("
StatusData:C_ID " int primary key, "
StatusData:C_CREATED_AT " int, "
StatusData:C_USER " text, "
StatusData:C_TEXT " text)")))
(*:execSQL db sql)
(Log:d "Yamba-DB" (string-append "onCreated sql: " sql))))
((onUpgrade (db ::SQLiteDatabase) (oldVersion ::int) (newVersion ::int))
;; instead of an alter table we just drop and recreate
(*:execSQL db (string-append "drop table if exists " StatusData:TABLE))
(Log:d "Yamba-DB" "onUpdated")
(onCreate db)))
(define-simple-class StatusData ()
(DATABASE ::String allocation: 'static access: 'final init: "timeline.db")
(VERSION ::int allocation: 'static access: 'final init: 1)
(TABLE ::String allocation: 'static access: 'final init: "timeline")
(C_ID ::String allocation: 'static access: 'final init: BaseColumns:_ID)
(C_CREATED_AT ::String allocation: 'static access: 'final init: "created_at")
(C_TEXT ::String allocation: 'static access: 'final init: "text")
(C_USER ::String allocation: 'static access: 'final init: "user")
(C_SOURCE ::String allocation: 'static access: 'final init: "source")
;; (GET_ALL_ORDER_BY ::String allocation: 'static access: 'final
;; init: C_CREATED_AT + " DESC")
;; (MAX_CREATED_AT_COLUMNS ::String allocation: 'static access: 'final
;; init: "max(" + C_CREATED_AT + ")")
(db-helper ::dbHelper allocation: 'static access: '(private final))
((*init* (context_ ::Context))
(set! db-helper (make dbHelper context_)))
((insert-or-ignore (values ::ContentValues))
(Log:d "StatusData insert of ignore" values)
(let ((db ::SQLiteDatabase (db-helper:getWritableDatabase)))
(try-finally
(try-catch (db:insertWithOnConflict TABLE #!null values
SQLiteDatabase:CONFLICT_IGNORE)
(e android.database.SQLException
(Log:e "Yamba-Updater SQL" e)
#f))
(db:close))))
((get-status-updates)
(let ((db ::SQLiteDatabase (db-helper:getReadableDatabase)))
(try-finally
((db-helper:getReadableDatabase):query
TABLE #!null #!null #!null #!null #!null
(string-append C_CREATED_AT " DESC"))
(db:close))))
((get-latest-status-created-at-time)
(let ((db ::SQLiteDatabase (db-helper:getReadableDatabase)))
(try-finally
(let ((cursor ::Cursor
(db:query TABLE
(String[] (string-append "max(" C_CREATED_AT ")"))
#!null #!null #!null #!null #!null)))
(try-finally
(if (cursor:moveToNext) (cursor:getLong 0) java.lang.Long:MIN_VALUE)
(cursor:close)))
(db:close))))
((get-status-text-by-id (id ::long))
(let ((db ::SQLiteDatabase (db-helper:getReadableDatabase)))
(try-finally
(let ((cursor ::Cursor (db:query TABLE
(String[] C_TEXT)
(string-append C_ID "=" id)
#!null #!null #!null #!null)))
(try-finally
(if (cursor:moveToNext) (cursor:getString 0) #!null)
(cursor:close)))
(db:close)))))
| true |
5c8104b32f86aa45f4342c12d3f2124dda52516a
|
be9a21ff79da7fe4c3de913a5bdc12500d1b0113
|
/test.scm
|
c11f93d5cf8179b4d9b63897b6b08cd048d389ac
|
[] |
no_license
|
ktakashi/SRFI-105
|
4919e406add799f41180e25db380c05d07b21eaf
|
ae89467ce31bf7f116763a442db8a5636a7fa08b
|
refs/heads/master
| 2020-03-29T16:23:44.964153 | 2012-11-08T08:00:29 | 2012-11-08T08:00:29 | 5,586,403 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 7,660 |
scm
|
test.scm
|
(add-load-path "./")
#!read-macro=curly-infix
(import (rnrs)
(srfi :105)
(srfi :64))
(test-begin "SRFI-105 tests")
;; from examples
;; http://srfi.schemers.org/srfi-105/mail-archive/msg00080.html
(define-syntax test-infix
(syntax-rules ()
((_ expect expr)
(test-equal expr expect
(let ((p (open-string-input-port expr)))
(read p))))))
;; from SRFI-105 samples
(test-infix '(<= n 5) "{n <= 5}")
(test-infix '(+ x 1) "{x + 1}")
(test-infix '(+ a b c) "{a + b + c}")
(test-infix '(,op x y z) "{x ,op y ,op z}")
(test-infix '(eqv? x `a) "{x eqv? `a}")
(test-infix '(eq? 'a b) "{'a eq? b}")
(test-infix '(+ n-1 n-2) "{n-1 + n-2}")
(test-infix '(* a (+ b c)) "{a * {b + c}}")
(test-infix '(+ a (- b c)) "{a + {b - c}}")
(test-infix '(- (+ a b) c) "{{a + b} - c}")
(test-infix '(and (> a 0) (>= b 1)) "{{a > 0} and {b >= 1}}")
(test-infix '() "{}")
(test-infix '5 "{5}")
(test-infix '(- x) "{- x}")
(test-infix '(>= (length x) 6) "{length(x) >= 6}")
(test-infix '(+ (f x) (g y) (h z)) "{f(x) + g(y) + h(z)}")
(test-infix '(+ (f a b) (g h)) "{(f a b) + (g h)}")
(test-infix '(+ (f a b) (g h)) "{f(a b) + g(h)}")
(test-infix ''(+ a (f b) x) "'{a + f(b) + x}")
(test-infix '(/ (- a) b) "{(- a) / b}")
(test-infix '(/ (- a) b) "{-(a) / b}")
(test-infix '(cos q) "{cos(q)}")
(test-infix '(e) "{e{}}")
(test-infix '(pi) "{pi()}")
(test-infix ''(f x) "{'f(x)}")
;; we can't support SRFI-38 style with SRFI-105
;;(test-infix '#0=(f #0#) "{#1=f(#1#)}")
(test-infix '(f (g (h x))) "{ (f (g h(x))) }")
(test-infix '#(1 2 (f a) 4) "{#(1 2 f(a) 4)}")
(test-infix '(f (h x)) "{(f #;g(x) h(x))}")
(test-infix '(map - ns) "{(map - ns)}")
(test-infix '(map - ns) "{map(- ns)}")
(test-infix '(* n (factorial (- n 1))) "{n * factorial{n - 1}}")
(test-infix '(* 2 (sin (- x))) "{2 * sin{- x}}")
(test-infix '($nfx$ 3 + 4 +) "{3 + 4 +}")
(test-infix '($nfx$ 3 + 4 + 5 +) "{3 + 4 + 5 +}")
(test-infix '($nfx$ a . z) "{a . z}")
(test-infix '($nfx$ a + b - c) "{a + b - c}")
(test-infix '(read . options) "{read(. options)}")
(test-infix '((a x) y) "{a(x)(y)}")
(test-infix '($bracket-apply$ x a) "{x[a]}")
(test-infix '($bracket-apply$ y a b) "{y[a b]}")
(test-infix '((f (- n 1)) x) "{f{n - 1}(x)}")
(test-infix '((f (- n 1)) (- y 1)) "{f{n - 1}{y - 1}}")
(test-infix '($bracket-apply$ (f (- x)) y) "{f{- x}[y]}")
;; === sweeten ===
(test-infix '(* (length indent-increment) 3) "{length(indent-increment) * 3}")
(test-infix '(- (length indent) (length marked-indent-increment))
"{length(indent) - length(marked-indent-increment)}")
(test-infix '(and (> (length indent) min-indent-marking)
(last-indent-unmarked indent))
"{{length(indent) > min-indent-marking} and last-indent-unmarked(indent)}")
(test-infix '(< (length x) boring-length) "{length(x) < boring-length}")
(test-infix '(+ count-so-far 1) "{count-so-far + 1}")
(test-infix '(>= (length x) 3) "{length(x) >= 3}")
(test-infix '(<= (length x) 6) "{length(x) <= 6}")
(test-infix '(and (pair? x) (null? (cdr x))) "{pair?(x) and null?(cdr(x))}")
(test-infix '(+ pos (length item)) "{pos + length(item)}")
(test-infix '(< (+ pos (length item-sameline)) maxwidth)
"{{pos + length(item-sameline)} < maxwidth}")
(test-infix '(+ pos (length item-sameline)) "{pos + length(item-sameline)}")
(test-infix '(< (+ (posdent indent-already indent) newlen) maxwidth)
"{{posdent(indent-already indent) + newlen} < maxwidth}")
(test-infix '(and (memq (car m) cuddle-first-parameter) (>= (length m) 3))
"{memq(car(m) cuddle-first-parameter) and {length(m) >= 3}}")
(test-infix '(and (< length-asline max-unit-character-length)
(fits-width? indent-already indent length-asline)
(< (general-length m) max-unit-list-length))
"{ {length-asline < max-unit-character-length} and fits-width?(indent-already indent length-asline) and {general-length(m) < max-unit-list-length} }")
(test-infix '(and (char? (car x))
(null? (cdr x))
(eq? (car x) #\newline))
"{char?(car(x)) and null?(cdr(x)) and {car(x) eq? #\\newline}}")
(test-infix '(and (not (eq? c next))
(memq next end-of-line-chars))
"{not{c eq? next} and memq(next end-of-line-chars)}")
(test-infix '(char=? c #\;) "{c char=? #\\;}")
(test-infix '(or (char=? c #\space) (char=? c tab))
"{{c char=? #\\space} or {c char=? tab}}")
;; === letterfall ===
(test-infix '(and (< 64 n) (<= n (+ 64 26)))
"{{ 64 < n } and { n <= { 64 + 26 }}}")
(test-infix '(- n 64 1)
"{ n - 64 - 1 }")
(test-infix '(and (< 96 n) (<= n (+ 96 26)))
"{{ 96 < n } and { n <= { 96 + 26 }}}")
(test-infix '(- n 96 1) "{ n - 96 - 1 }")
(test-infix '(and (<= 48 n) (<= n (+ 48 9)))
"{{ 48 <= n } and { n <= { 48 + 9 }}}")
(test-infix '(- n 48) "{ n - 48 }")
(test-infix '(char=? c #\-) "{ c char=? #\\- }")
(test-infix '(char=? c #\') "{ c char=? #\\' }")
(test-infix '(<= kv 126) "{ kv <= 126 }")
(test-infix '(= kv gdk:Escape) "{ kv = gdk:Escape }")
(test-infix '(char=? (char-toupper k) c) "{ char-toupper(k) char=? c }")
(test-infix '(+ col 1) "{ col + 1 }")
(test-infix '(- 20 (inexact->exact (floor (/ len 2))))
"{ 20 - inexact->exact(floor{ len / 2 })}")
(test-infix '(+ 7 n) "{ 7 + n }")
(test-infix '(+ 64 n 1) "{ 64 + n + 1 }")
(test-infix '(char=? (char-toupper k) char)
"{ char-toupper(k) char=? char }")
(test-infix '(+ score 1)
"{ score + 1 }")
(test-infix '(= (remainder nscore 10) 0)
"{{ nscore remainder 10 } = 0 }")
(test-infix '(+ level 1) "{ level + 1 }")
(test-infix '(char=? k esc-key) "{ k char=? esc-key }")
(test-infix '(+ line 1) "{ line + 1 }")
(test-infix '(= line 22) "{ line = 22 }")
(test-infix '(* (expt 0.75 level) 400) "{{ 0.75 expt level } * 400 }")
(test-infix '(and (< 96 n) (<= n (+ 96 26)))
"{{ 96 < n } and { n <= { 96 + 26 }}}")
(test-infix '(- n 32) "{ n - 32 }")
(test-infix '(* 40 25) "{ 40 * 25 }")
(test-infix '(= n (* 40 25)) "{ n = { 40 * 25 }}")
(test-infix '(+ n 1) "{ n + 1 }")
(test-infix '(+ x (* y 40)) "{ x + { y * 40 }}")
(test-infix '(+ cursor 1) "{ cursor + 1 }")
(test-infix '(>= cursor (* 40 25)) "{ cursor >= { 40 * 25 }}")
(test-infix '(= i end) "{ i = end }")
(test-infix '(+ i 1) "{ i + 1 }")
(test-infix '(/ screen-width 320) "{ screen-width / 320 }")
(test-infix '(/ screen-height 200) "{ screen-height / 200 }")
(test-infix '(+ x 1) "{ x + 1 }")
(test-infix '(+ y 1) "{ y + 1 }")
(test-infix '(- rescaled<x+1> rescaled<x>) "{ rescaled<x+1> - rescaled<x> }")
(test-infix '(- rescaled<y+1> rescaled<y>) "{ rescaled<y+1> - rescaled<y> }")
(test-infix '(+ (/ screen-width 2) (* (- x 160) scaling-factor))
"{{ screen-width / 2 } + {{ x - 160 } * scaling-factor }}")
(test-infix '(+ (/ screen-height 2) (* (- y 100) scaling-factor))
"{{ screen-height / 2 } + {{ y - 100 } * scaling-factor }}")
(test-infix '(/ n 40) "{ n / 40 }")
(test-infix '(- n (* l 40)) "{ n - { l * 40 }}")
;; I beleive the example was wrong, it needed to be wrapped with #\{ and #\}
(test-infix '(not (char=? (vector-ref display-screen n)
(vector-ref latest-screen n)))
"{not{ vector-ref(display-screen n) char=? vector-ref(latest-screen n) }}")
(test-infix '(+ n 1) "{ n + 1 }")
(test-infix '(* c 8) "{ c * 8 }")
(test-infix '(* l 8) "{ l * 8 }")
(test-infix '(= i 8) "{ i = 8 }")
(test-infix '(+ i 1) "{ i + 1 }")
(test-infix '(= x 8) "{ x = 8 }")
(test-infix '(= (logand line (expt 2 (- 7 x))) 0)
"{{ line logand { 2 expt { 7 - x }}} = 0}")
(test-infix '(+ basex x) "{ basex + x }")
(test-infix '(+ basey y) "{ basey + y }")
(test-infix '(+ x 1) "{ x + 1 }")
;; extra
;; some literals in currying-infix
(test-infix '(vector-ref #(a b c) 0) "{vector-ref(#(a b c) 0)}")
(test-infix '(+ #xFF #e10.1) "{#xFF + #e10.1}")
(test-end)
| true |
b5ffaeb163db2600d054643d2aaa7f147dd401b9
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System.Xml/system/xml/schema/xml-schema-group-ref.sls
|
9e141e875fee63116b63f22e81736ebbf86f5ffb
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 876 |
sls
|
xml-schema-group-ref.sls
|
(library (system xml schema xml-schema-group-ref)
(export new
is?
xml-schema-group-ref?
ref-name-get
ref-name-set!
ref-name-update!
particle)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new System.Xml.Schema.XmlSchemaGroupRef a ...)))))
(define (is? a) (clr-is System.Xml.Schema.XmlSchemaGroupRef a))
(define (xml-schema-group-ref? a)
(clr-is System.Xml.Schema.XmlSchemaGroupRef a))
(define-field-port
ref-name-get
ref-name-set!
ref-name-update!
(property:)
System.Xml.Schema.XmlSchemaGroupRef
RefName
System.Xml.XmlQualifiedName)
(define-field-port
particle
#f
#f
(property:)
System.Xml.Schema.XmlSchemaGroupRef
Particle
System.Xml.Schema.XmlSchemaGroupBase))
| true |
7b0e15b850295df58c72a620e01d0170438ee9c0
|
b389e2ae98c6a980ac889326e104fd366286c193
|
/test/testfiles/lambda4.scm
|
23e215206a5f83c49a7c106b2fa55f6fca194c74
|
[] |
no_license
|
adamrk/scheme2luac
|
1a0fbba81b4c2c0e06808bf93137cf5e0f1e9db7
|
5e64008b57a574c0afce72513363a176c7dcf299
|
refs/heads/master
| 2020-05-24T10:51:48.673627 | 2017-04-21T13:55:49 | 2017-04-21T13:55:49 | 84,849,528 | 22 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 15 |
scm
|
lambda4.scm
|
((lambda () 5))
| false |
510a3e620a73a6e2e3dc4ecc302f8e10d17544e2
|
f08220a13ec5095557a3132d563a152e718c412f
|
/logrotate/skel/usr/share/guile/2.0/sxml/upstream/assert.scm
|
e9e983d5be280b8f415ee9291645f59a1fdd8954
|
[
"Apache-2.0"
] |
permissive
|
sroettger/35c3ctf_chals
|
f9808c060da8bf2731e98b559babd4bf698244ac
|
3d64486e6adddb3a3f3d2c041242b88b50abdb8d
|
refs/heads/master
| 2020-04-16T07:02:50.739155 | 2020-01-15T13:50:29 | 2020-01-15T13:50:29 | 165,371,623 | 15 | 5 |
Apache-2.0
| 2020-01-18T11:19:05 | 2019-01-12T09:47:33 |
Python
|
UTF-8
|
Scheme
| false | false | 1,395 |
scm
|
assert.scm
|
;
; syntax: assert ?expr ?expr ... [report: ?r-exp ?r-exp ...]
;
; If (and ?expr ?expr ...) evaluates to anything but #f, the result
; is the value of that expression.
; If (and ?expr ?expr ...) evaluates to #f, an error is reported.
; The error message will show the failed expressions, as well
; as the values of selected variables (or expressions, in general).
; The user may explicitly specify the expressions whose
; values are to be printed upon assertion failure -- as ?r-exp that
; follow the identifier 'report:'
; Typically, ?r-exp is either a variable or a string constant.
; If the user specified no ?r-exp, the values of variables that are
; referenced in ?expr will be printed upon the assertion failure.
(define-syntax assert
(syntax-rules (report:)
((assert "doit" (expr ...) (r-exp ...))
(cond
((and expr ...) => (lambda (x) x))
(else
(error "assertion failure: ~a" (list '(and expr ...) r-exp ...)))))
((assert "collect" (expr ...))
(assert "doit" (expr ...) ()))
((assert "collect" (expr ...) report: r-exp ...)
(assert "doit" (expr ...) (r-exp ...)))
((assert "collect" (expr ...) expr1 stuff ...)
(assert "collect" (expr ... expr1) stuff ...))
((assert stuff ...)
(assert "collect" () stuff ...))))
(define-syntax assure
(syntax-rules ()
((assure exp error-msg)
(assert exp report: error-msg))))
| true |
e9c6040f4805b0df82c10c48823ed8301637a505
|
c39d4eda6c001b3aa98789232f9ce422369ece8e
|
/staged-utils.scm
|
95832bea37b7179d8c45f97c040a2a3d46732e82
|
[] |
no_license
|
namin/staged-miniKanren
|
43477369ab2150a6f26222b1b50ab008fb64f15a
|
af986fd3e8facf83d21db41826e4609b0d45e32d
|
refs/heads/master
| 2023-08-31T23:45:51.352139 | 2022-02-27T18:35:35 | 2022-02-27T18:35:35 | 109,611,513 | 115 | 16 | null | 2021-07-08T18:05:27 | 2017-11-05T19:59:39 |
Scheme
|
UTF-8
|
Scheme
| false | false | 6,292 |
scm
|
staged-utils.scm
|
;; # Utilities for quick-fixing scope
(define union
(lambda (a b)
(if (null? a) b
(union (cdr a) (if (memq (car a) b) b (cons (car a) b))))))
(define diff
(lambda (a b)
(if (null? b) a (remq (car b) (diff a (cdr b))))))
(define is-reified-var?
(lambda (x)
(and
(symbol? x)
(let ((s (symbol->string x)))
(and (> (string-length s) 2)
(char=? (string-ref s 0) #\_)
(char=? (string-ref s 1) #\.))))))
(define fix-scope1
(lambda (t . in-cdr)
(cond
((symbol? t)
(list t (if (is-reified-var? t) (list t) (list))))
((and (null? in-cdr) (pair? t) (eq? 'fresh (car t)))
(let ((r (map fix-scope1 (cddr t))))
(let ((body (map car r))
(vs (fold-right union
(filter (lambda (x) (not (is-reified-var? x))) (cadr t))
(map cadr r))))
(list `(fresh ,vs . ,body) (list)))))
((and (pair? t) (eq? 'lambda (car t)) (not (null? (cdr t))))
(let ((r (map fix-scope1 (cddr t))))
(let ((body (map car r))
(vs (diff (fold-right union '() (map cadr r))
(if (symbol? (cadr t)) (list (cadr t)) (cadr t)))))
(list `(lambda ,(cadr t) . ,body) vs))))
((pair? t)
(let ((ra (fix-scope1 (car t)))
(rb (fix-scope1 (cdr t) #t)))
(list (cons (car ra) (car rb)) (union (cadr ra) (cadr rb)))))
(else (list t (list))))))
(define fix-scope2
(lambda (t s . in-cdr)
(cond
((and (null? in-cdr) (pair? t) (eq? 'fresh (car t)))
(let ((ds (diff (cadr t) (filter is-reified-var? s)))
(us (union (cadr t) s)))
`(fresh ,ds . ,(map (lambda (x) (fix-scope2 x us)) (cddr t)))))
((and (pair? t) (eq? 'lambda (car t)) (not (null? (cdr t))))
(let ((us (union (if (symbol? (cadr t)) (list (cadr t)) (cadr t)) s)))
`(lambda ,(cadr t) . ,(map (lambda (x) (fix-scope2 x us)) (cddr t)))))
((pair? t)
(cons (fix-scope2 (car t) s) (fix-scope2 (cdr t) s #t)))
(else t))))
(define fix-scope
(lambda (t)
(car (fix-scope2 (fix-scope1 t) '()))))
(define (unique-result r)
(cond
((null? r)
(error 'gen "staging failed"))
((not (null? (cdr r)))
(for-each
(lambda (i x) (printf "result ~a: ~a\n" (+ 1 i) x))
(iota (length r))
r)
(error 'gen "staging non-deterministic"))
(else (car r))))
(define (layer? tag r)
(and (pair? r) (pair? (cdr r)) (eq? tag (cadr r))))
(define (code-layer? r)
(layer? '!! r))
(define (constraint-layer? r)
(layer? '$$ r))
(define (maybe-remove-constraints r)
(if (constraint-layer? r)
(car r)
r))
(define (convert-constraints r)
(cond
((constraint-layer? r)
(printf "processing constraints: ~a\n" (cddr r))
(process-constraints (cddr r)))
(else '())))
(define (process-constraints cs)
(cond
((null? cs) '())
(else (append (process-constraint (car cs))
(process-constraints (cdr cs))))))
(define (process-constraint c)
(printf "processing constraint: ~a\n" c)
(cond
((eq? (car c) '=/=)
(map (lambda (x) (cons '=/=
(list (miniexpand (caar x)) (miniexpand (cadar x)))))
(cdr c)))
((eq? (car c) 'absento)
(map (lambda (x) (cons 'absento
(list (miniexpand (car x)) (miniexpand (cadr x)))))
(cdr c)))
((eq? (car c) 'sym)
(map (lambda (x) `(symbolo ,x)) (cdr c)))
((eq? (car c) 'num)
(map (lambda (x) `(numbero ,x)) (cdr c)))
(else (error 'process-constraint "unexpected constraint" c))))
(define (reified-var? x)
(and (symbol? x)
(let ((chars (string->list (symbol->string x))))
(and (char=? #\_ (car chars))
(char=? #\. (cadr chars))))))
(define (miniexpand x)
(cond
((reified-var? x) x)
(else `(quote ,x))))
(define (reified-expand x)
(cond
((reified-var? x) x)
((pair? x)
(list 'cons
(reified-expand (car x))
(reified-expand (cdr x))))
(else `(quote ,x))))
;; # Helpers for turning functional procedure into relational one
(define res '())
(define (gen-func r . inputs)
(let ((r (unique-result r)))
(let ((cs (convert-constraints r))
(r (maybe-remove-constraints r)))
(unless (code-layer? r)
(error 'gen-func "no code generated" r))
(set! res
(fix-scope
`(lambda (,@inputs out)
(fresh () ,@cs (== ,(reified-expand (car r)) out) . ,(caddr r)))))
res)))
(define (gen-func-rel r . inputs)
(let ((r (unique-result r)))
(let ((cs (convert-constraints r))
(r (maybe-remove-constraints r)))
(unless (code-layer? r)
(error 'gen-func "no code generated" r))
(set! res
(fix-scope
`(lambda (,@inputs)
(fresh () ,@cs (== ,(reified-expand (car r)) (list ,@inputs)) . ,(caddr r)))))
res)))
(define gen
(lambda (p-name inputs rhs . contexts)
(let ((context (if (null? contexts) (lambda (x) x) (car contexts))))
(apply gen-func
(run 100 (q)
(fresh (env inputs^)
(ext-env*o inputs inputs^ initial-env env)
(make-list-of-symso inputs inputs^)
(eval-expo #t
(context
`(letrec ((,p-name (lambda ,inputs ,rhs)))
(,p-name . ,inputs)))
env
q)))
inputs))))
(define (gen-hole query result . extra)
(gen-func
(run 100 (q)
(if (null? extra) succeed ((car extra) q))
(eval-expo #t
(query q)
initial-env
result))))
(define (syn-hole n query result . extra)
(printf "running first stage\n")
(let ((e (eval (apply gen-hole query result
(if (null? extra) '() (cdr extra))))))
(printf "running second stage\n")
(run n (q)
(if (null? extra) succeed ((car extra) q))
(e q))))
(define ex
(lambda (p-name inputs rhs)
(let ((r (eval (gen p-name inputs rhs))))
(run 1 (q)
(apply r (append inputs (list q)))))))
(define fwd1
(lambda (r)
(lambda (x)
(run* (q) (r x q)))))
| false |
bbeb26f0d90020403d244fcd599d5413542496f7
|
0fc1a4a1b3e6be19efdd792eb996d33047bcc9b6
|
/scratch/test.scm
|
65e6d326e3623c5f2648431f5cf1984b78c41c81
|
[] |
no_license
|
yinso/sexp-parser
|
bb2b0ea079b34415684c257e9d2becc635fbf3e5
|
b363f7bc4bc0e0c7dcad5b08a671fdd586b730d2
|
refs/heads/master
| 2020-05-18T00:02:10.028193 | 2014-11-19T22:02:54 | 2014-11-19T22:02:54 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 259 |
scm
|
test.scm
|
(import (rnrs syntax-case (6)))
(define-syntax or
(lambda (x)
(syntax-case x ()
[(_) (syntax #f)]
[(_ e) (syntax e)]
[(_ e1 e2 e3 ...)
(syntax (let ([t e1])
(if t t (or e2 e3 ...))))])))
| true |
068b00dc072e2fadc87281b1c1d7fef9ee2312ad
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/System/system/component-model/design/component-changing-event-args.sls
|
008af2caf5dfe5363e727bf5355f118ee00f1e0e
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 920 |
sls
|
component-changing-event-args.sls
|
(library (system component-model design component-changing-event-args)
(export new is? component-changing-event-args? component member)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
System.ComponentModel.Design.ComponentChangingEventArgs
a
...)))))
(define (is? a)
(clr-is System.ComponentModel.Design.ComponentChangingEventArgs a))
(define (component-changing-event-args? a)
(clr-is System.ComponentModel.Design.ComponentChangingEventArgs a))
(define-field-port
component
#f
#f
(property:)
System.ComponentModel.Design.ComponentChangingEventArgs
Component
System.Object)
(define-field-port
member
#f
#f
(property:)
System.ComponentModel.Design.ComponentChangingEventArgs
Member
System.ComponentModel.MemberDescriptor))
| true |
1df1c37fd064eab1b6141851f582d514b8e8bc15
|
2bcf33718a53f5a938fd82bd0d484a423ff308d3
|
/programming/sicp/ch2/ex-2.55.scm
|
f3792816c676ae84674bd9b02fcdb6f7bfe7615e
|
[] |
no_license
|
prurph/teach-yourself-cs
|
50e598a0c781d79ff294434db0430f7f2c12ff53
|
4ce98ebab5a905ea1808b8785949ecb52eee0736
|
refs/heads/main
| 2023-08-30T06:28:22.247659 | 2021-10-17T18:27:26 | 2021-10-17T18:27:26 | 345,412,092 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 439 |
scm
|
ex-2.55.scm
|
#lang scheme
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-16.html#%_thm_2.55
;; Explain the following:
> (car ''abc)
'quote
;; ' is the special form of a procedure `quote`
(car ''abc) ;; interpreter reads as:
(car (quote (quote abc))) ;; rewriting the first quote:
(car '(quote abc)) ;; this is the list literal (list quote abc)
;; The car of the list (list quote abc) is just quote
| false |
9c657c0208c5224b0377791689e6ac238adecb1e
|
fd9daee097ae6e309e4abf907513487315e91ca5
|
/src/handle.ss
|
5892fc52af728838ce28521989b7420991c8f34d
|
[
"MIT"
] |
permissive
|
tqtifnypmb/choices
|
93c96e49e557f4c6871aab28eb8f0abae70bb901
|
d3dd2d31cb43f46d7a73c07611521f5cde7b57c2
|
refs/heads/master
| 2021-01-19T19:56:36.293246 | 2017-05-03T08:06:48 | 2017-05-03T08:06:48 | 88,466,503 | 2 | 2 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,472 |
ss
|
handle.ss
|
;handle
(define-record-type uv-handle
(fields (immutable ptr) (mutable cbs)))
(define (replace-cb handle type cb)
(let-values (((old remain)
(partition (lambda (x) (eq? (car x) type)) (uv-handle-cbs handle))))
(unless (null? old)
(unlock-object (address->code (cdar old))))
(if (eq? #f cb)
(uv-handle-cbs-set! handle remain)
(uv-handle-cbs-set! handle (append remain
(list (cons type
(code->address cb))))))))
(define (release-cb handle type)
(replace-cb handle type #f))
(define (uv-handle-type-cb handle type)
(cadar (filter (lambda (x) (eq? (car x) type)) (uv-handle-cbs handle))))
;common
(define uv-is-active
(foreign-procedure "uv_is_active" (uptr) boolean))
(define uv-is-closing
(foreign-procedure "uv_is_closing" (uptr) boolean))
(define uv-ref
(foreign-procedure "uv_ref" (uptr) void))
(define uv-unref
(foreign-procedure "uv_unref" (uptr) void))
(define uv-had-ref
(foreign-procedure "uv_has_ref" (uptr) boolean))
(define uv-close-f
(foreign-procedure "uv_close" (uptr uptr) void))
(define (uv-close handle cb)
(let ((fcb (cb->fcb handle 'close cb (uptr) void)))
(uv-close-f (uv-handle-ptr handle) (code->address fcb))))
(define (uv-handle-size type)
(handle-size (indexed-list-index handle-type
type)))
(define (release-handle handle)
(for-each (lambda (cb) (unlock-object (address->code (cdr cb))))
(uv-handle-cbs handle))
(foreign-free (uv-handle-ptr handle)))
(define handle-size
(foreign-procedure "uv_handle_size" (int) size_t))
(define handle-type
(list->indexed-list '(unknown
async
check
fs-event
fs-poll
handle
idle
named-pipe
poll
prepare
process
stream
tcp
timer
tty
udp
signal
file)))
(define-syntax new
(syntax-rules ()
((_ init size) (let* ((obj (foreign-alloc size))
(res (init obj)))
(if (= res 0)
obj
(begin (foreign-free obj)
#f))))
((_ loop init size) (let* ((obj (foreign-alloc size))
(res (init loop obj)))
(if (= res 0)
obj
(begin (foreign-free obj)
#f))))
((_ loop init size arg ...) (let* ((obj (foreign-alloc size))
(res (init loop obj arg ...)))
(if (= res 0)
obj
(begin (foreign-free obj)
#f))))))
(define-syntax new-handle
(syntax-rules ()
((_ loop init type) (let ((p (new loop init (uv-handle-size type))))
(if (boolean? p)
(raise (make-message-condition "can't alloc new handle"))
(make-uv-handle p '()))))
((_ loop init type arg ...) (let ((p (new loop init (uv-handle-size type) arg ...)))
(if (boolean? p)
(raise (make-message-condition "can't alloc new handle"))
(make-uv-handle p '()))))))
(define-syntax handle-start
(syntax-rules ()
((_ start handle cb) (let ((fcb (cb->fcb handle 'start cb (uptr) void)))
(start (uv-handle-ptr handle) (code->address fcb))))
((_ start handle cb arg ...) (let ((fcb (cb->fcb handle 'start cb (uptr) void)))
(start (uv-handle-ptr handle) (code->address fcb) arg ...)))))
(define-syntax handle-stop
(syntax-rules ()
((_ stop handle) (begin (release-cb handle 'start)
(stop (uv-handle-ptr handle))))))
(define-syntax cb->fcb
(syntax-rules ()
((_ handle type cb sig ...) (let ((fcb (foreign-callable cb sig ...)))
(replace-cb handle type fcb)
(lock-object fcb)
fcb))))
| true |
bbadf34d59f1bbe9d792c02f7f8590d96afee598
|
5ed839cef4cc1d6f54095ca90e8e58538d229d81
|
/Graphics/font.scm
|
3c66e93aea5ad7479d919e40f0e5485551754e8f
|
[] |
no_license
|
kksym/sfml-scm
|
418bf1e6ce82da213f0eac195d3736ddc5522c85
|
128563ec9b428d42b4adf8fa3f39f2dcc62e6a12
|
refs/heads/master
| 2020-04-26T14:47:01.105316 | 2012-05-18T16:02:58 | 2012-05-18T16:02:58 | 2,973,821 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 851 |
scm
|
font.scm
|
(define-foreign-type sfFont "sfFont" '())
(define sf-font-create-from-file
(foreign-lambda (c-pointer sfFont)
"sfFont_CreateFromFile" c-string))
(define sf-font-copy
(foreign-lambda (c-pointer sfFont)
"sfFont_Copy" (c-pointer sfFont)))
(define sf-font-destroy
(foreign-lambda void
"sfFont_Destroy" (c-pointer sfFont)))
(define sf-font-get-kerning
(foreign-lambda int
"sfFont_GetKerning"
(c-pointer sfFont) unsigned-integer32 unsigned-integer32 unsigned-integer))
(define sf-font-get-line-spacing
(foreign-lambda int
"sfFont_GetLineSpacing" (c-pointer sfFont) unsigned-integer))
(define sf-font-get-texture
(foreign-lambda (c-pointer sfTexture)
"sfFont_GetTexture" (c-pointer sfFont) unsigned-integer))
(define sf-font-get-default-font
(foreign-lambda (c-pointer sfFont)
"sfFont_GetDefaultFont"))
| false |
9499a0a422dea559664ec0e0eaf9b0e3de0bff09
|
903de163d1f58d7a8ef8881e0b915bfbcdbe5eab
|
/lib/thunknyc/types.sld
|
371315ef3427161ee4dd062ef4f132a0e09674a0
|
[
"MIT"
] |
permissive
|
thunknyc/i7t
|
00c2960d61ae1d94a4e58f52d6542951f83e3287
|
75be3ab8dfd3b0f8c24fdd3cf307f6bfd7af588f
|
refs/heads/master
| 2020-04-11T08:29:09.997459 | 2018-12-16T14:36:15 | 2018-12-16T14:36:15 | 161,644,827 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 734 |
sld
|
types.sld
|
(define-library (thunknyc types)
(import (scheme red) (only (chibi ast) type-of))
(export <opcode> <procedure> <set> <string> <pair> <vector> <hash-table>
<integer> <flonum> <bignum> <ratio> <complex>)
(begin
(define <opcode> (type-of +))
(define <procedure> (type-of write))
(define <set> (type-of (set equal?)))
(define <string> (type-of ""))
(define <pair> (type-of (cons 'a 'b)))
(define <vector> (type-of #()))
(define <hash-table> (type-of (hash-table equal?)))
(define <integer> (type-of 42))
(define <flonum> (type-of 42.0))
(define <bignum> (type-of 424242424242424242424242424242424242))
(define <ratio> (type-of 22/7))
(define <complex> (type-of 3.0+4.0i))))
| false |
4f39a4d620d90d10a1272f1eaef655e8f2c978b5
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/sparse-texture.sls
|
3a7e0e06907bb18490dbe918f3d4de47a2d2b9a3
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,394 |
sls
|
sparse-texture.sls
|
(library (unity-engine sparse-texture)
(export new
is?
sparse-texture?
update-tile
unload-tile
update-tile-raw
tile-width
tile-height
is-created?)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...) #'(clr-new UnityEngine.SparseTexture a ...)))))
(define (is? a) (clr-is UnityEngine.SparseTexture a))
(define (sparse-texture? a) (clr-is UnityEngine.SparseTexture a))
(define-method-port
update-tile
UnityEngine.SparseTexture
UpdateTile
(System.Void
System.Int32
System.Int32
System.Int32
UnityEngine.Color32[]))
(define-method-port
unload-tile
UnityEngine.SparseTexture
UnloadTile
(System.Void System.Int32 System.Int32 System.Int32))
(define-method-port
update-tile-raw
UnityEngine.SparseTexture
UpdateTileRaw
(System.Void System.Int32 System.Int32 System.Int32 System.Byte[]))
(define-field-port
tile-width
#f
#f
(property:)
UnityEngine.SparseTexture
tileWidth
System.Int32)
(define-field-port
tile-height
#f
#f
(property:)
UnityEngine.SparseTexture
tileHeight
System.Int32)
(define-field-port
is-created?
#f
#f
(property:)
UnityEngine.SparseTexture
isCreated
System.Boolean))
| true |
11710e847143b2706079342c785ce58e91ca8fa2
|
b9eb119317d72a6742dce6db5be8c1f78c7275ad
|
/double-dummy-solver/trick.ss
|
1388a5939e9af6e39649897eeb7211706ec9a3b5
|
[] |
no_license
|
offby1/doodles
|
be811b1004b262f69365d645a9ae837d87d7f707
|
316c4a0dedb8e4fde2da351a8de98a5725367901
|
refs/heads/master
| 2023-02-21T05:07:52.295903 | 2022-05-15T18:08:58 | 2022-05-15T18:08:58 | 512,608 | 2 | 1 | null | 2023-02-14T22:19:40 | 2010-02-11T04:24:52 |
Scheme
|
UTF-8
|
Scheme
| false | false | 6,889 |
ss
|
trick.ss
|
#! /bin/sh
#| Hey Emacs, this is -*-scheme-*- code!
#$Id$
exec mzscheme -qu "$0" ${1+"$@"}
|#
#lang scheme
(print-struct #t)
(require (only-in rnrs/base-6 assert)
(only-in (lib "1.ss" "srfi" )
alist-copy
circular-list
every
last
last-pair
reduce
take
)
(only-in (lib "43.ss" "srfi")
vector-copy
vector-every
vector-fold
vector-for-each
vector-map
)
"card.ss"
(lib "trace.ss")
(only-in (lib "etc.ss") compose)
(lib "pretty.ss"))
(provide
(rename-out (add-card t:add-card))
(rename-out (my-make-trick make-trick))
(rename-out (my-trick-cards trick-cards))
*seats*
*trump-suit*
annotated-cards
augmented-rank
last-play
leader
led-suit
mt
partner
rotate
rotate-until
seat<
trick-complete?
trick-ref
trick?
whose-turn
winner
winner/int
with-seat-circle
)
(display "$Id$" (current-error-port))
(newline (current-error-port))
(define *seats* '(n e s w))
(assert (zero? (remainder (* *num-suits* *num-ranks*) (length *seats*))))
(define (seat< a b)
(> (length (memq a *seats*))
(length (memq b *seats*))))
(define *trump-suit*
(make-parameter
#f
(let ((allowed (cons #f *suits*)))
(lambda (s)
(unless (memq s allowed)
(raise-mismatch-error
'*trump-suit*
(format "wanted one of ~s, not " allowed)
s))
s))))
(define (rotate seq steps)
(if (positive? steps)
(rotate (append (cdr seq)
(list (car seq)))
(sub1 steps))
seq))
(define (rotate-until seq criterion)
(define (inner seq counter)
(unless (< counter (length seq))
(error 'rotate-until "We're in an endless loop! seq is ~s; criterion is ~s" seq
criterion))
(if (criterion seq)
seq
(inner (rotate seq 1) (add1 counter))))
(inner seq 0))
(define (rotate-until-car-eq seq sought)
(rotate-until seq (lambda (x) (eq? (car x) sought))))
;; rotate the seats until SEAT is first, then apply the proc to the
;; list.
(define (with-seat-circle seat proc)
(assert (memq seat *seats*))
(proc (rotate-until-car-eq *seats* seat)))
(define (partner seat)
(with-seat-circle seat caddr))
(define (trick-print trick port write?)
(vector-for-each (lambda (i cs)
(fprintf port "~a:~a" (cdr cs) (car cs))
(when (< i (sub1 (vector-length (trick-card-seat-pairs trick))))
(fprintf port ", ")))
(trick-card-seat-pairs trick)))
(define-values (s:trick make-trick trick? s:trick-ref trick-set!)
(make-struct-type 'trick #f 1 0 #f
(list (cons prop:custom-write trick-print)) #f))
(define (trick-card-seat-pairs t) (s:trick-ref t 0))
(define (trick-complete? t)
(= (length *seats*) (vector-length (trick-card-seat-pairs t))))
(define (my-is-trick? thing)
(and (trick? thing)
(let ((v (trick-card-seat-pairs thing)))
(and (vector v)
(vector-every pair? v)))))
(define (my-make-trick cards leader)
(define (all-distinct? seq)
(let ((h (make-hash)))
(for-each (lambda (i)
(hash-set! h (card->number i #f) #t))
seq)
(= (length seq)
(hash-count h))))
(assert (list? cards))
(assert ((lambda (c) (not (null? c))) cards))
(assert ((lambda (cs) (every card? cs)) cards))
(assert (all-distinct? cards))
(assert ((lambda (leader) (memq leader *seats*)) leader))
;;(printf "Making trick led by ~a ... " leader)
(with-seat-circle
leader
(lambda (sc)
(let ((l (length cards)))
(make-trick (list->vector (map cons cards (take sc l))))))))
;(trace my-make-trick)
;; for testing -- allows me to build a trick with a lot less typing
;; e.g., (mt 'north 'c3 'c6 'c9 'cj)
(define (mt* leader . card-syms)
(let ((rv (my-make-trick
(map mc* card-syms)
leader)))
rv))
;(trace mt)
;; similar to mt, but even nicer: I don't have to quote the symbols.
(define-syntax mt
(syntax-rules ()
((_ leader card-syms ...)
(apply mt* `(leader card-syms ...)))))
(define (leader t)
(cdr (vector-ref (trick-card-seat-pairs t) 0)))
(define (annotated-cards t)
(vector->list (trick-card-seat-pairs t)))
(define (my-trick-cards t)
(map car (vector->list (trick-card-seat-pairs t))))
;; nondestructive
(define (add-card t c)
(assert (my-is-trick? t))
(assert (not (trick-complete? t)))
(let* ((new-length (add1 (vector-length (trick-card-seat-pairs t))))
(v (vector-copy (trick-card-seat-pairs t) 0 new-length))
(next-seat (with-seat-circle (cdr (vlast (trick-card-seat-pairs t))) cadr)))
(vector-set! v (sub1 new-length) (cons c next-seat))
(make-trick v)))
;;(trace add-card)
(define (trick-ref t k)
(car (vector-ref (trick-card-seat-pairs t)
k)))
(define (vlast v)
(vector-ref v (sub1 (vector-length v))))
(define (last-play t)
(let ((pairs (trick-card-seat-pairs t)))
(assert (not (zero? (vector-length pairs))))
(car (vlast pairs))))
(define (whose-turn t)
(assert (not (trick-complete? t)))
(with-seat-circle
(cdr (vlast (trick-card-seat-pairs t)))
cadr))
(define (led-suit t)
(card-suit (trick-ref t 0)))
;; the "trick-taking power" of this card. It's pretty much the rank,
;; except: if it's in the trump suit, it gets a boost of 13 so that it
;; beats all cards from all other suits; and if we were passed a
;; trick, and it's not of the led suit, then its power is 0.
(define (augmented-rank card . t)
(when (pair? t)
(set! t (car t)))
(cond
((eq? (*trump-suit*)
(card-suit card))
(+ (card-rank card) *num-ranks*))
((and t
(not (null? t))
(not (eq? (led-suit t)
(card-suit card))))
0)
(else
(card-rank card))) )
;;(trace augmented-rank)
;; returns just a seat
(define (winner t)
(cdr (winner/int t)))
;; returns (cons card seat)
;; TODO -- consider keeping statistics on whether the players followed
;; the dictum "second hand low; third hand high". It might turn out
;; that they mostly do, which would be cool, since I never explcitily
;; taught them to.
(define (winner/int t)
(assert (trick-complete? t))
(vector-fold
(lambda (index state element)
(if (> (augmented-rank (car element) t)
(augmented-rank (car state) t))
element
state))
(vector-ref (trick-card-seat-pairs t) 0)
(trick-card-seat-pairs t)))
;(trace winner)
| true |
7c78047bededd1ac99ec697e3b45e2dc2fcd5687
|
a10b9011582079d783282e79e4cfdc93ace6f6d3
|
/exercises/04/04accumulate.scm
|
5ffe1418192a77a0db900eea6ebc2f78847b08e2
|
[] |
no_license
|
hristozov/fpkn1415
|
2996a488c1feba6a595e466ca42a1418b03e2a77
|
9b44eb9c9ff4402ff22c2a5f55285c1f59b99722
|
refs/heads/master
| 2016-09-05T13:02:38.264241 | 2015-08-22T14:11:05 | 2015-08-22T14:11:05 | 24,793,324 | 11 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 648 |
scm
|
04accumulate.scm
|
(load "../../lib/scm/unit.scm")
(define (identity x)
x)
(define (plus1 x)
(+ x 1))
(define (accumulate-iter term accum-func initial a next b)
(define (accumulate-helper c acc)
(if (> c b)
acc
(accumulate-helper (next c) (accum-func acc (term c)))))
(accumulate-helper a initial))
(define (accumulate term accum-func initial a next b)
(define (accumulate-helper c)
(if (> c b)
initial
(accum-func (term c) (accumulate-helper (next c)))))
(accumulate-helper a))
(define (_square x) (* x x))
(assert= 36 (accumulate _square * 1 1 plus1 3))
(assert= 36 (accumulate-iter _square * 1 1 plus1 3))
| false |
9e6e6eecc7f115702de699ba5cba6ee093817d6d
|
ec0f122fdcf4ceaf5e9e183575a460006c19ebe0
|
/src/db/db-interface.scm
|
8e49b24ae16892b00fe4721ed605137d8797a936
|
[] |
no_license
|
ThomasHintz/keep-the-records
|
d96e6253ebc3d2e11ee37277a6293c7365b25f9b
|
c20e648e831bed2ced3f2f74bfc590dc06b5f076
|
refs/heads/master
| 2021-01-13T02:37:41.053488 | 2013-07-19T04:18:44 | 2013-07-19T04:18:44 | 1,272,038 | 2 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,104 |
scm
|
db-interface.scm
|
; author: Thomas Hintz
; email: [email protected]
; license: bsd
; Copyright (c) 2012-2013, Thomas Hintz
; All rights reserved.
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
; * Neither the name of the author nor the
; names of its contributors may be used to endorse or promote products
; derived from this software without specific prior written permission.
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
; DISCLAIMED. IN NO EVENT SHALL THOMAS HINTZ BE LIABLE FOR ANY
; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(module db-interface
(;; params
db:sep db:path db:flags
;; procs
db:store db:read db:list db:update-list db:remove-from-list db:delete
db:pause db:resume db:paused? db:connect db:disconnect
;; constants
db:flag-no-lock db:flag-writer db:flag-reader db:flag-create
)
(import scheme chicken ports srfi-13 data-structures)
(use tokyocabinet srfi-1 srfi-13 srfi-18)
(load "src/utils/macs") (import macs)
(load "src/utils/threading-extras") (import threading-extras)
;;; constants
(define db:flag-no-lock TC_HDBONOLCK)
(define db:flag-writer TC_HDBOWRITER)
(define db:flag-reader TC_HDBOREADER)
(define db:flag-create TC_HDBOCREAT)
;;; params
(define db:sep (make-global-parameter "/"))
(define db:path (make-global-parameter 'undefined))
(define db:flags (make-global-parameter
(fx+ TC_HDBONOLCK (fx+ TC_HDBOWRITER (fx+ TC_HDBOREADER TC_HDBOCREAT)))))
(define db (make-global-parameter 'undefined))
; all keys that start with this are for indexes
; to keep indexes from clashing with db data
(define list-index-prefix (make-global-parameter "the-list-index"))
(define (contains? l e)
(not (eq? (filter (lambda (le) (equal? le e)) l) '())))
(define (dash->space s)
(string-fold (lambda (c o) (string-append o (if (char=? #\- c) " " (->string c)))) "" s))
(define (space->dash s)
(string-fold (lambda (c o) (string-append o (if (char=? #\space c) "-" (->string c)))) "" s))
(define (id->name id)
(string-titlecase (dash->space id)))
(define (name->id name)
(string-downcase (space->dash name)))
(define (list->path list)
(fold (lambda (e o)
(string-append o (db:sep) e))
""
list))
(define *active-db-queries* (make-mutex/value 'active-db-queries 0))
(define *paused* (make-mutex/value 'paused #f))
(define *resume* (make-condition-variable 'resume))
(define *query-finished* (make-condition-variable 'query-finished))
(define-syntax with-db
(syntax-rules ()
((_ f ...)
(begin
(mutex-wait! *paused* (lambda (paused) (eq? paused #f)) *resume*)
(mutex-update! *active-db-queries* add1)
(let ((r
(handle-exceptions
e
(begin (mutex-update! *active-db-queries* sub1)
(condition-variable-signal! *query-finished*)
(error e))
(begin f ...))))
(mutex-update! *active-db-queries* sub1)
(condition-variable-signal! *query-finished*)
r)))))
;;; db funcs
(define (db:store data . path-list)
(with-db
(let ((k (name->id (list->path path-list)))
(v (with-output-to-string (lambda () (write data)))))
(tc-hdb-put! (db) k v) #t)))
(define (db:read . path-list)
(with-db
(let ((val (tc-hdb-get (db) (name->id (list->path path-list)))))
(if val
(with-input-from-string val (lambda () (read)))
'not-found))))
(define (db:list . path-list)
(with-db
(let ((r (apply db:read (append path-list `(,(list-index-prefix))))))
(if (eq? r 'not-found)
'()
r))))
(define (db:update-list data . path-list)
(with-db
(let* ((p (append path-list `(,(list-index-prefix))))
(l (apply db:read p))
(ls (if (eq? l 'not-found) '() l)))
(or (contains? ls data) (apply db:store (cons data ls) p)))))
(define (db:remove-from-list data . path-list)
(with-db
(let* ((p (append path-list `(,(list-index-prefix))))
(l (apply db:read p))
(ls (if (eq? l 'not-found) '() l)))
(apply db:store
(filter (lambda (e)
(not (equal? e data)))
ls)
p))))
(define (db:delete . path-list)
(with-db
(let ((k (name->id (list->path path-list))))
(tc-hdb-delete! (db) k))))
(define (db:paused?)
(equal? (mutex-specific *paused*) #t))
(define (db:pause)
(if (not (db:paused?))
(begin
(mutex-update! *paused* (lambda (v) #t))
(mutex-wait! *active-db-queries*
(lambda (num-queries) (= num-queries 0))
*query-finished*)
(db:disconnect)
#t)
(error 'already-paused!)))
(define (db:resume)
(if (db:paused?)
(begin
(db:connect)
(mutex-update! *paused* (lambda (v) #f))
(condition-variable-broadcast! *resume*)
#t)
(error 'not-paused!)))
(define (db:connect)
(db (tc-hdb-open (db:path) flags: (db:flags))))
(define (db:disconnect)
(tc-hdb-close (db))
(db 'undefined))
)
| true |
a46e765989263e35844ff7e5ab2e2cc70ca4c51b
|
ebc5db754946092d65c73d0b55649c50d0536bd9
|
/2020/day19.scm
|
1e5ae5626f6d45e186055557ecd943c4e755a3ef
|
[] |
no_license
|
shawnw/adventofcode
|
6456affda0d7423442d0365a2ddfb7b704c0aa91
|
f0ecba80168289305d438c56f3632d8ca89c54a9
|
refs/heads/master
| 2022-12-07T22:54:04.957724 | 2022-12-02T07:26:06 | 2022-12-02T07:26:06 | 225,129,064 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,571 |
scm
|
day19.scm
|
#!/usr/local/bin/csi -s
(import (chicken format)
(chicken io)
(chicken string)
(srfi 1)
(srfi 13)
(srfi 14)
)
(declare (fixnum-arithmetic) (block))
(define (read-rules #!optional (port (current-input-port)))
(let loop ((acc '())
(line (read-line port)))
(if (or (eof-object? line) (string=? line ""))
(reverse! acc)
(loop (cons line acc) (read-line port)))))
(define (max-ruleno rules)
(+ 1 (fold (lambda (r acc) (max (car r) acc)) 0 rules)))
(define (numbers->list nums)
(map string->number (string-split nums " ")))
(define (parse-branches branches)
(map (lambda (branch)
(let ((branch (string-trim-both branch char-set:whitespace)))
(if (char=? (string-ref branch 0) #\")
(string-ref branch 1)
(numbers->list branch)))) branches))
(define (parse-rules raw)
(let loop ((rules raw)
(acc '()))
(if (null? rules)
(let* ((size (max-ruleno acc))
(rulevec (make-vector size #f)))
(for-each (lambda (rule)
(vector-set! rulevec (car rule) (cdr rule)))
acc)
rulevec)
(let* ((parts (string-split (car rules) ":"))
(ruleno (string->number (car parts)))
(branches (string-split (second parts) "|")))
(loop (cdr rules) (cons (cons ruleno (parse-branches branches)) acc))))))
(define (match-rules line rules)
(letrec ((match-helper
(lambda (ridx lidx)
(any (lambda (ruleset)
(let loop ((ruleset ruleset)
(lidx lidx))
(cond ((null? ruleset) lidx)
((char? ruleset)
(if (char=? (string-ref line lidx) ruleset)
(+ lidx 1)
#f))
(else
(let ((res (match-helper (car ruleset) lidx)))
(if (number? res)
(loop (cdr ruleset) res)
res))))))
(vector-ref rules ridx)))))
(let ((match (match-helper 0 0)))
(if (number? match)
(= (string-length line) match)
match))))
(define (solve1 lines rules)
(count (cut match-rules <> rules) lines))
(define rules (parse-rules (read-rules)))
(define lines (read-lines))
(printf "Part 1: ~A~%" (solve1 lines rules))
| false |
c22ab7b658823fb6b5832c9206538a1519c7de6e
|
4b5dddfd00099e79cff58fcc05465b2243161094
|
/chapter_3/exercise_3_3.scm
|
65f70f68516b985f69e1402263ea1da8337dca24
|
[
"MIT"
] |
permissive
|
hjcapple/reading-sicp
|
c9b4ef99d75cc85b3758c269b246328122964edc
|
f54d54e4fc1448a8c52f0e4e07a7ff7356fc0bf0
|
refs/heads/master
| 2023-05-27T08:34:05.882703 | 2023-05-14T04:33:04 | 2023-05-14T04:33:04 | 198,552,668 | 269 | 41 |
MIT
| 2022-12-20T10:08:59 | 2019-07-24T03:37:47 |
Scheme
|
UTF-8
|
Scheme
| false | false | 823 |
scm
|
exercise_3_3.scm
|
#lang racket
;; P154 - [练习 3.3]
(define (make-account balance right-password)
(define (withdraw amount)
(if (>= balance amount)
(begin
(set! balance (- balance amount))
balance)
"Insufficient funds"))
(define (deposit amount)
(set! balance (+ balance amount))
balance)
(define (incorrect-password . args)
"Incorrect password")
(define (dispatch try-password m)
(if (eq? try-password right-password)
(cond ((eq? m 'withdraw) withdraw)
((eq? m 'deposit) deposit)
(else (error "Unknown request -- MAKE-ACCOUNT" m)))
incorrect-password))
dispatch)
;;;;;;;;;;;;;;;;;;;;
(define acc (make-account 100 'secret-password))
((acc 'secret-password 'withdraw) 40)
((acc 'some-other-password 'deposit) 50)
| false |
23480be16e4ba00b72f476832b097a4761110967
|
6d8516960c6fd93e063d23d5d3edad82dd75cb16
|
/ch02.scm
|
ba080127a5195c1e58eb8e7ae354633c22d2dc7b
|
[] |
no_license
|
d11wtq/L.i.S.P
|
e600a7fd527079d8ab0df7296345b3f9be990ace
|
6e826ddba7f2e725d767e76b464f0baa32405e39
|
refs/heads/master
| 2021-01-19T11:02:17.834736 | 2014-03-31T11:12:36 | 2014-03-31T11:12:36 | 18,139,047 | 0 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,579 |
scm
|
ch02.scm
|
;;;;
;;; Lisp in Small Pieces, Chapter 2.
;;;
;;; A very naive direct-execution Lisp2 interpreter.
;;;;
(define *env.init* (list))
(define *env.global* *env.init*)
(define (evaluate sexp env denv)
"Defines the core evaluator of this LiSP."
(if (atom? sexp)
(if (symbol? sexp)
(lookup sexp env)
sexp)
(case (car sexp)
((quote) (cadr sexp))
((if) (if (evaluate (cadr sexp) env denv)
(evaluate (caddr sexp) env denv)
(evaluate (cadddr sexp) env denv)))
((begin) (eprogn (cdr sexp) env denv))
((set!) (update! (cadr sexp)
env
(evaluate (caddr sexp) env denv)))
((lambda) (make-function (cadr sexp)
(cddr sexp)
env))
(else (invoke (evaluate (car sexp) env denv)
(evlis (cdr sexp) env denv)
denv)))))
(define (atom? sexp)
"Return #t if the sexp is not a pair."
(not (pair? sexp)))
(define (lookup-with-error-function id env error-fn)
"Find the value of id in the a-list env, otherwise invoke error-fn."
(if (pair? env)
(if (eq? (caar env) id)
(cdar env)
(lookup-with-error-function id (cdr env) error-fn))
(error-fn id)))
(define (lookup id env)
"Find the value of id in the a-list env, otherwise error."
(lookup-with-error-function
id
env
(lambda (id)
(error "No such binding" id))))
(define (update! id env value)
"Change the value stored in the binding id in the a-list env."
(if (pair? env)
(if (eq? (caar env) id)
(begin
(set-cdr! (car env) value)
value)
(update! id (cdr env) value))
(error "No such binding" id)))
(define (eprogn sexps env denv)
"Evaluate a sequence of sexps and return the last one."
(if (pair? sexps)
(if (pair? (cdr sexps))
(begin
(evaluate (car sexps) en denvv)
(eprogn (cdr sexps) env denv))
(evaluate (car sexps) env denv))
(list)))
(define (evlis sexps env denv)
"Evaluate a list of sexps and return the evaluated list."
(if (pair? sexps)
(cons (evaluate (car sexps) env denv)
(evlis (cdr sexps) env denv))
(list)))
(define (extend env ids values)
"Extend the environment env with new ids and values."
(cond
((pair? ids) (if (pair? values)
(cons (cons (car ids)
(car values))
(extend env (cdr ids) (cdr values)))
(error "Not enough values")))
((null? ids) (if (null? values)
env
(error "Too many values")))
((symbol? ids) (cons (cons ids values)
env))))
(define (make-function params body env)
"Create a function with params and body in env."
(lambda (values denv)
(eprogn body
(extend env params values)
denv)))
(define (invoke f args denv)
"Call a function in the interpreter."
(if (procedure? f)
(f args denv)
(error "Cannot apply value:" f)))
(define (run-repl)
"Run a simple repl session for our interpreter."
(define (repl)
(let ((value (evaluate (read)
*env.global*
*env.init*)))
(if (eof-object? value)
(newline)
(begin
(display value)
(newline)
(repl)))))
(display "Entering interactive ch01 repl.")
(newline)
(display "To exit, type (quit) or hit ctrl-d.")
(newline)
(newline)
(repl))
(define-syntax definitial
(syntax-rules ()
"Macro to define an initial variable in the global env."
((definitial name)
(begin
(set! *env.global*
(cons (cons 'name 'void)
*env.global*))
'name))
((definitial name value)
(begin
(set! *env.global*
(cons (cons 'name value) *env.global*))
'name))))
(define-syntax defprimitive
(syntax-rules ()
"Macro to bind a primitive scheme function to the global env."
((defprimitive name fn arity)
(definitial name
(lambda (values denv)
(if (= arity (length values))
(apply fn values)
(error "Bad arity" (list 'name values))))))))
(define (quit)
"Provides a function to exit the repl."
(read (open-input-string "")))
(definitial bind/de
(lambda (args denv)
(if (= 3 (length args))
(let ((id (car args))
(value (cadr args))
(thunk (caddr args)))
(invoke thunk
(list)
(extend denv
(list id)
(list value))))
(error "Bad arity" 'bind/de))))
(definitial assoc/de
(lambda (args denv)
(if (= 2 (length args))
(let ((id (car args))
(default (cadr args)))
(lookup-with-error-function id denv default))
(error "Bad arity" 'assoc/de))))
;;; Primitives
(definitial t #t)
(definitial f #f)
(definitial nil (list))
(definitial list (lambda (values denv)
(apply list values)))
(defprimitive cons cons 2)
(defprimitive car car 1)
(defprimitive cdr cdr 1)
(defprimitive set-cdr! set-cdr! 2)
(defprimitive + + 2)
(defprimitive - - 2)
(defprimitive * * 2)
(defprimitive / / 2)
(defprimitive eq? eq? 2)
(defprimitive < < 2)
(defprimitive > > 2)
(defprimitive = = 2)
(defprimitive quit quit 0)
| true |
c234b1c62588174fe72cf483083ec6b028f60c2b
|
65b48b5107bb153e2658d23f0b76f7dccb4216a4
|
/.config/i3/api/move
|
065cdd4a000c75fb477de3adb255cb3d46d02b99
|
[] |
no_license
|
ambirdsall/dots
|
ab0bfff2c4d5875ad611ddd8604a78a9a789126e
|
0bb92c54ed8cb69e7806e1b2f2a545ed6c5e8579
|
refs/heads/master
| 2023-08-31T21:30:16.591672 | 2023-08-29T04:24:35 | 2023-08-29T04:24:35 | 218,208,254 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 86 |
move
|
#!/usr/bin/env -S guile -e main -s
!#
(define (main args)
(write args)
(newline))
| false |
|
f2e29cdf3141cd03ac872cfd04557271888b1085
|
bdfa935097ef39f66c7f18856accef422ef39128
|
/parts/qa0/tree/scheme/error.ss
|
6dfb97206e8f591b8b0a491a93c561135fedac85
|
[
"MIT"
] |
permissive
|
djm2131/qlua
|
213f5ed4b692b1b03d2ff1a78d09ea9d2d9fe244
|
737bfe85228dac5e9ae9eaab2b5331630703ae73
|
refs/heads/master
| 2020-04-18T15:01:06.117689 | 2019-02-06T15:23:27 | 2019-02-06T15:23:27 | 162,349,914 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,273 |
ss
|
error.ss
|
;; Error handling
#fload "sfc.sf"
#fload "print.ss"
;; Capture the output port
(define error-port (current-output-port))
;; Reader errors
(define (r-error* msg arg*)
(newline error-port)
(q-display "QA0: Reader error: " error-port)
(q-display msg error-port)
(for-each (lambda (arg)
(write-char #\space)
(if (string? arg) (q-display arg error-port) (q-write arg)))
arg*)
(newline error-port)
(flush-output-port error-port)
(reset))
(define-syntax r-error
(syntax-rules ()
[(_ msg arg ...) (r-error* msg (list arg ...))]))
;; Syntax errors
(define (s-error* msg arg*)
(newline error-port)
(q-display "Syntax error: " error-port)
(q-fprint* error-port msg arg*)
(newline error-port)
(flush-output-port error-port)
(reset))
(define-syntax s-error
(syntax-rules ()
[(_ msg arg ...) (s-error* msg (list arg ...))]))
;; Internal compiler errors, aka ICE
(define (ic-error* loc msg arg*)
(newline error-port)
(q-display "QA0 ICE: " error-port)
(q-display loc error-port)
(q-display ": " error-port)
(q-fprint* error-port msg arg*)
(newline error-port)
(flush-output-port error-port)
(reset))
(define-syntax ic-error
(syntax-rules ()
[(_ loc msg arg ...) (ic-error* loc msg (list arg ...))]))
| true |
9f2df0dd279e3f976a07b8bf66c67a70722f4f9b
|
be32518c6f54b0ab1eaf33f53405ac1d2e1023c2
|
/np/lang/macros/structure-meta-vars.sld
|
ce004ca1d734eec0163dbbea858456aff5d572c4
|
[
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
ilammy/np
|
7990302bc30fe7802a7f4fc33d8fa7449ef8b011
|
0e3cbdea0eb2583f9b272d97bc408011af6a7947
|
refs/heads/master
| 2016-09-05T17:11:03.893011 | 2015-06-13T16:37:39 | 2015-06-13T16:37:39 | 23,740,287 | 1 | 0 | null | 2015-06-13T16:39:43 | 2014-09-06T17:19:46 |
Scheme
|
UTF-8
|
Scheme
| false | false | 2,137 |
sld
|
structure-meta-vars.sld
|
(define-library (np lang macros structure-meta-vars)
;;;
;;; Structural analysis of meta-variable specifier lists
;;;
(export %verify:meta-var-name
%verify:meta-var-modification
$can-be:meta-var-addition?
$can-be:meta-var-removal?
$squash-extension-meta-variables)
(import (scheme base)
(sr ck)
(sr ck lists)
(sr ck maps)
(sr ck predicates)
(np lang macros verify-utils))
(begin
;;;
;;; Standalone meta-vars
;;;
(define-verifier/symbol %verify:meta-var-name
("Name of the meta-variable must be an identifier") )
;;;
;;; Extension meta-vars
;;;
(define-syntax $can-be:meta-var-addition?
(syntax-rules (quote +)
((_ s '(+ meta-vars ...)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-syntax $can-be:meta-var-removal?
(syntax-rules (quote -)
((_ s '(- meta-vars ...)) ($ s '#t))
((_ s _) ($ s '#f)) ) )
(define-verifier %verify:meta-var-modification
(syntax-rules (quote + -)
((_ s '(k t) 'term '(+ meta-vars ...))
($ s ($and '(%verify:meta-var-addition-list '(k (term . t)) '(meta-vars ...))
'($every? '(%verify:meta-var-name '(k t)) '(meta-vars ...)) )))
((_ s '(k t) 'term '(- meta-vars ...))
($ s ($and '(%verify:meta-var-removal-list '(k (term . t)) '(meta-vars ...))
'($every? '(%verify:meta-var-name '(k t)) '(meta-vars ...)) )))
((_ s '(k t) 'term _)
($ k '("Invalid syntax of the meta-variable modification" (term . t)))) ) )
(define-verifier/nonempty-list %verify:meta-var-addition-list
("At least one meta-variable should be specified for addition") )
(define-verifier/nonempty-list %verify:meta-var-removal-list
("At least one meta-variable should be specified for removal") )
;;;
;;; Squashers
;;;
(define-syntax $squash-extension-meta-variables
(syntax-rules (quote)
((_ s 'meta-vars) ($ s ($concatenate ($map '$cdr 'meta-vars)))) ) )
) )
| true |
4d3df94fc1962943d1a7c7ab86993722c2673b2d
|
f5083e14d7e451225c8590cc6aabe68fac63ffbd
|
/cs/01-Programming/cs61a/course/library/proj2/load.scm
|
0ed71f748a6a63658ab5502bfd950394d2718be1
|
[] |
no_license
|
Phantas0s/playground
|
a362653a8feb7acd68a7637334068cde0fe9d32e
|
c84ec0410a43c84a63dc5093e1c214a0f102edae
|
refs/heads/master
| 2022-05-09T06:33:25.625750 | 2022-04-19T14:57:28 | 2022-04-19T14:57:28 | 136,804,123 | 19 | 5 | null | 2021-03-04T14:21:07 | 2018-06-10T11:46:19 |
Racket
|
UTF-8
|
Scheme
| false | false | 678 |
scm
|
load.scm
|
;;; Sanity Check Fall 2000
;;; CS61A Project 2
;;; Erik Klavon / [email protected]
;;; load.scm
;;; This program checks to be sure that the student's code loads without
;;; producing an error.
;;; Definitions
; name of user's file to be checked
(define user-file "picture.scm")
; name and path of library file to be loaded
(define lib-file "~cs61a/lib/picture.scm")
; dummy defs so we can load picture.scm and users code
(define segments->painter (lambda (list) (lambda (frame) list)))
;;;; Code
; this loads the users code
(load user-file)
; we need to load library file just in case the user didn't
(load lib-file)
; this loads the users code again
(load user-file)
| false |
cd1866d4a201ac4e5fd4f81877b5c1a34a909c6e
|
ede85c0ac51cfd70db50bb76d4621068947f5798
|
/fannkuch-redux.scm
|
7afacc70455a68a52cb952a4698a7d9adff66869
|
[] |
no_license
|
b4284/scheme-stuff
|
536ec94c14f3bfd4c57a827cdf1d886cf577858d
|
2f3061d1efac6dc0ff511202028f92739e7cdbf1
|
refs/heads/master
| 2016-09-06T09:52:42.806105 | 2012-12-28T03:24:21 | 2012-12-28T03:24:21 | 32,452,722 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,021 |
scm
|
fannkuch-redux.scm
|
(define (rotate ls)
(if (null? ls)
ls
(append (cdr ls) (list (car ls)))))
(define (permutations ls)
(let ((len (length ls)))
(if (= 1 len)
(list ls)
(let r ((result '()) (ls1 ls) (rotate-times len))
(if (= 0 rotate-times)
result
(r (append result
(map (lambda (x) (cons (car ls1) x))
(permutations (cdr ls1))))
(rotate ls1) (- rotate-times 1)))))))
(define (permutation2 ls) ;generator style
(let ((len (length ls)))
(if (= 1 len)
(list ls)
(let r ((result '()) (ls1 ls) (rotate-times len))
(if (= 0 rotate-times)
result
(r (append result
(map (lambda (x) (cons (car ls1) x))
(permutations (cdr ls1))))
(rotate ls1) (- rotate-times 1)))))))
(define (m1 v k)
(lambda (x) (k (cons v x))))
(define (reverse-by-first-elem ls)
(let ((n (car ls)))
(append (reverse (list-head ls n))
(list-tail ls n))))
(define (max-flips ls)
(let r ((times 0) (nls ls))
(let ((e1 (car nls)))
(if (= 1 e1)
times
(r (+ 1 times) (reverse-by-first-elem nls))))))
;; (define q '(1 2 3 4 5 6 7 8 9 10 11 12))
;; (display (apply max (map max-flips (permutations ))))
;; (newline)
;; (max-flips '(7 6 5 4 3 2 1))
(define (process p)
(set! pile (cons (max-flips p) pile)))
(define (incred-permutation proc cur rest)
(if (null? rest)
(proc (max-flips cur))
(for-each
(lambda (x) (incred-permutation
proc
(cons x cur)
(remove (lambda (y) (= x y)) rest)))
rest)))
(define (incred-permutation2 proc cur rest)
(if (null? rest)
(proc (max-flips cur))
(for-each2
(lambda (M R) (incred-permutation2
proc
(cons M cur)
R))
rest)))
(define (for-each2 P L)
(let R ((mid (car L))
(left '())
(right (cdr L)))
(P mid (append (reverse left) right))
(if (not (null? right))
(R (car right)
(cons mid left)
(cdr right)))))
(define (for-each3 P L)
q
;; (for-each2 (lambda (M R)
;; (format #t "middle is: ~a\n" M)
;; (format #t "rest is: ~a\n" R))
;; '(1 2 3 4))
;; (use-modules (statprof))
;; (statprof-reset 0 50000 #t)
;; (statprof-start)
(begin
(let* ((max 0)
(f (lambda (x) (if (> x max)
(set! max x)))))
;; (use-modules (srfi srfi-1))
;; (incred-permutation f '() '(1 2 3 4 5 6 7 8))
;; (incred-permutation2 f '() '(1 2 3 4 5 6 7 8 9 10 11 12))
(incred-permutation2 f '() '(1 2 3 4 5 6 7 8 9 10 11 12))
(display max)
(newline)))
;; (statprof-stop)
;; (statprof-display)
;; (define q (make-bytevector 7))
(define (test . x)
(format #t "~a" x))
(test 1 2 3 4)
| false |
b1a26000388488e27f8de5bd3d9f8ad384ebabaf
|
d6910224fa09f702ff00eda6d83ba0631dd36e13
|
/1-29.scm
|
d18eaaf38562b1a60ed25d8d586bebe4f7cad2f2
|
[] |
no_license
|
jeffgyf/sicp_homework
|
786dd9f5eed315018279d79ad8a1c73662d9f4ce
|
f2564b06e19362af78206b51cd963ff34787a8e8
|
refs/heads/master
| 2020-04-12T14:17:03.342146 | 2019-05-06T05:54:27 | 2019-05-06T05:54:27 | 162,547,609 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,303 |
scm
|
1-29.scm
|
;E2.78
(define (attach-tag type-tag contents)
(cond
((number? contents) contents)
(else (cons type-tag contents))))
(define (type-tag datum)
(if (pair? datum)
(car datum)
(if (number? datum)
'scheme-number
(error "type-tag" "bad tagged datum" datum))))
(define (contents datum)
(if (pair? datum)
(cdr datum)
(if (number? datum)
datum
(error "type-tag" "bad tagged datum" datum))))
;2.79-2.80
(define (equ? d1 d2)
(apply-generic 'equ? d1 d2))
(define (=zero? d)
(apply-generic '=zero? d))
;scheme-number-package
(put 'equ? '(scheme-number scheme-number) =)
(put '=zero? '(scheme-number)
(lambda (n)
(= n 0)))
;rational-package
(put 'equ? '(rational rational)
(lambda (r1 r2)
(and
(= (numer r1) (numer r2))
(= (denom r1) (denom r2)))))
(put '=zero? '(rational)
(lambda (r)
(and
(= (numer r1) 0))))
;complex-package
(put 'equ '(complex complex)
(lambda (c1 c2)
(and
(= (magnitude c1) (magnitude c2))
(= (angle c1) (angle c2)))))
(put '=zero '(complex)
(lambda (c)
(and
(= (magnitude c) 0))))
| false |
37bf79914a0989d68857fa494844e0586e5fec85
|
8f9b45f0ad99a668cf9b1e72830fe640e1105cc0
|
/t/util/version.scm
|
40092edd0b125d503e57d16c58b2825e393ed2dc
|
[] |
no_license
|
picrin-scheme/sulfuric
|
56bbb5a01056c232b6b96e93e0e63af866088e75
|
7318dddfdf26b72a2c810246b8511e7d1ff9b70d
|
refs/heads/master
| 2016-09-05T16:46:22.849594 | 2015-01-20T17:28:46 | 2015-01-20T17:28:46 | 29,534,762 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 5,149 |
scm
|
version.scm
|
(load "./piclib/util.scm")
(load "./piclib/util/version.scm")
(import (scheme base)
(picrin test)
(sulfuric util version))
(test-begin)
(test #t (version= (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version= (make-version 1 2) (make-version 1 2)))
(test #t (version= (make-version 1) (make-version 1)))
(test #f (version= (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version= (make-version 1 3 3) (make-version 1 2 2)))
(test #f (version= (make-version 2 1 3) (make-version 1 2 3)))
(test #f (version/= (make-version 1 2 3) (make-version 1 2 3)))
(test #f (version/= (make-version 1 2) (make-version 1 2)))
(test #f (version/= (make-version 1) (make-version 1)))
(test #t (version/= (make-version 1 2 3) (make-version 1 3 2)))
(test #t (version/= (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version/= (make-version 2 1 3) (make-version 1 2 3)))
(test #t (version< (make-version 1 2 3) (make-version 1 2 4)))
(test #f (version< (make-version 1 2 3) (make-version 1 2 2)))
(test #t (version< (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version< (make-version 1 3 3) (make-version 1 2 2)))
(test #f (version< (make-version 1 2 3) (make-version 1 2 3)))
(test #f (version< (make-version 1 2) (make-version 1 2)))
(test #f (version< (make-version 1) (make-version 1)))
(test #t (version< (make-version 1 2 3) (make-version 2 1 3)))
(test #f (version< (make-version 2 1 3) (make-version 1 2 3)))
(test #t (version<= (make-version 1 2 3) (make-version 1 2 4)))
(test #f (version<= (make-version 1 2 3) (make-version 1 2 2)))
(test #t (version<= (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version<= (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version<= (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version<= (make-version 1 2) (make-version 1 2)))
(test #t (version<= (make-version 1) (make-version 1)))
(test #t (version<= (make-version 1 2 3) (make-version 2 1 3)))
(test #f (version<= (make-version 2 1 3) (make-version 1 2 3)))
(test #f (version> (make-version 1 2 3) (make-version 1 2 4)))
(test #t (version> (make-version 1 2 3) (make-version 1 2 2)))
(test #f (version> (make-version 1 2 3) (make-version 1 3 2)))
(test #t (version> (make-version 1 3 3) (make-version 1 2 2)))
(test #f (version> (make-version 1 2 3) (make-version 1 2 3)))
(test #f (version> (make-version 1 2) (make-version 1 2)))
(test #f (version> (make-version 1) (make-version 1)))
(test #f (version> (make-version 1 2 3) (make-version 2 1 3)))
(test #t (version> (make-version 2 1 3) (make-version 1 2 3)))
(test #f (version>= (make-version 1 2 3) (make-version 1 2 4)))
(test #t (version>= (make-version 1 2 3) (make-version 1 2 2)))
(test #f (version>= (make-version 1 2 3) (make-version 1 3 2)))
(test #t (version>= (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version>= (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version>= (make-version 1 2) (make-version 1 2)))
(test #t (version>= (make-version 1) (make-version 1)))
(test #f (version>= (make-version 1 2 3) (make-version 2 1 3)))
(test #t (version>= (make-version 2 1 3) (make-version 1 2 3)))
(test #t (version= (make-version 1 2 3) (string->version "1.2.3")))
(test #t (version= (make-version 1 2) (string->version "1.2")))
(test #t (version= (make-version 1) (string->version "1")))
(test "1.2.3" (version->string (string->version "1.2.3")))
(test (list 1 2 3) (version->list (string->version "1.2.3")))
(test #t (version~ (make-version 1 2 3) (make-version 1 2 4)))
(test #t (version~ (make-version 1 2 3) (make-version 1 2 2)))
(test #f (version~ (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version~ (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version~ (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version~ (make-version 1 2) (make-version 1 2)))
(test #t (version~ (make-version 1) (make-version 1)))
(test #f (version~ (make-version 1 2 3) (make-version 2 1 3)))
(test #f (version~ (make-version 2 1 3) (make-version 1 2 3)))
(test #f (version>~ (make-version 1 2 3) (make-version 1 2 4)))
(test #t (version>~ (make-version 1 2 3) (make-version 1 2 2)))
(test #f (version>~ (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version>~ (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version>~ (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version>~ (make-version 1 2) (make-version 1 2)))
(test #t (version>~ (make-version 1) (make-version 1)))
(test #f (version>~ (make-version 1 2 3) (make-version 2 1 3)))
(test #f (version>~ (make-version 2 1 3) (make-version 1 2 3)))
(test #t (version<~ (make-version 1 2 3) (make-version 1 2 4)))
(test #f (version<~ (make-version 1 2 3) (make-version 1 2 2)))
(test #f (version<~ (make-version 1 2 3) (make-version 1 3 2)))
(test #f (version<~ (make-version 1 3 3) (make-version 1 2 2)))
(test #t (version<~ (make-version 1 2 3) (make-version 1 2 3)))
(test #t (version<~ (make-version 1 2) (make-version 1 2)))
(test #t (version<~ (make-version 1) (make-version 1)))
(test #f (version<~ (make-version 1 2 3) (make-version 2 1 3)))
(test #f (version<~ (make-version 2 1 3) (make-version 1 2 3)))
(test-end)
| false |
eeb822093098388d3c57c9f5248de893a3d2cac7
|
2e50e13dddf57917018ab042f3410a4256b02dcf
|
/etc/R7RS/src/normalization.sch
|
810e4277708425ee518cf737c7c8ed7772dbc607
|
[
"MIT",
"LicenseRef-scancode-other-copyleft",
"LicenseRef-scancode-other-permissive",
"GPL-2.0-or-later",
"LGPL-2.0-or-later",
"BSD-2-Clause",
"LGPL-2.1-or-later",
"GPL-1.0-or-later"
] |
permissive
|
koba-e964/picrin
|
c0ca2596b98a96bcad4da9ec77cf52ce04870482
|
0f17caae6c112de763f4e18c0aebaa73a958d4f6
|
refs/heads/master
| 2021-01-22T12:44:29.137052 | 2016-07-10T16:12:36 | 2016-07-10T16:12:36 | 17,021,900 | 0 | 0 |
MIT
| 2019-05-17T03:46:41 | 2014-02-20T13:55:33 |
Scheme
|
UTF-8
|
Scheme
| false | false | 8,201 |
sch
|
normalization.sch
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Copyright (c) 2006 Michael Sperber
; All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; 1. Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; 2. Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
; 3. The name of the authors may not be used to endorse or promote products
; derived from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
; IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Majorly hacked for Larceny by William D Clinger, 3 August 2006.
; Hacked again for Larceny's test/Lib by W D Clinger, 30 May 2007.
; Converted into an R6RS benchmark by W D Clinger, 28 November 2007.
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(import (rnrs base)
(rnrs unicode)
(rnrs bytevectors)
(rnrs lists)
(rnrs control)
(rnrs exceptions)
(rnrs conditions)
(rnrs io ports)
(rnrs io simple))
; Given a string and a starting index,
; returns the index of the first character in the string
; at or following the starting index that is not a hex digit.
; Returns the length of the string if no such character is found.
(define (index-of-next-non-hex-digit s i)
(let ((n (string-length s)))
(let loop ((i i))
(if (< i n)
(case (string-ref s i)
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9
#\a #\b #\c #\d #\e #\f
#\A #\B #\C #\D #\E #\F)
(loop (+ i 1)))
(else
i))
n))))
; Given a string of hex digits, returns its value as an integer.
(define (hexstring->int s)
(define (hexdigit->int c)
(case c
((#\0) 0)
((#\1) 1)
((#\2) 2)
((#\3) 3)
((#\4) 4)
((#\5) 5)
((#\6) 6)
((#\7) 7)
((#\8) 8)
((#\9) 9)
((#\a #\A) 10)
((#\b #\B) 11)
((#\c #\C) 12)
((#\d #\D) 13)
((#\e #\E) 14)
((#\f #\F) 15)
(else (error 'hexstring->int "Bad hex digit: " c))))
(let ((n (string-length s)))
(do ((i 0 (+ i 1))
(result 0 (+ (* 16 result) (hexdigit->int (string-ref s i)))))
((= i n) result))))
; Given a non-comment line from NormalizationTest.txt,
; returns the 5 strings parsed from that line (as multiple values).
(define (parse-scalar-values s)
(let ((size (string-length s)))
(let column-loop ((start 0) (count 0) (rev-columns '()))
(if (= count 5)
(apply values (reverse rev-columns))
(let sv-loop ((start start) (rev-svs '()))
(let* ((i (index-of-next-non-hex-digit s start))
(n (hexstring->int (substring s start i))))
(if (char=? #\space (string-ref s i))
(sv-loop (+ 1 i) (cons n rev-svs))
(column-loop (+ 1 i) (+ 1 count)
(cons (list->string
(map integer->char
(reverse (cons n rev-svs))))
rev-columns)))))))))
; Crude test rig.
(define total-tests 0)
(define total-failed 0)
(define total-inputs 0)
(define current-input "")
(define failed-inputs '())
(define (normalization-test-init!)
(set! total-tests 0)
(set! total-failed 0)
(set! total-inputs 0)
(set! current-input "")
(set! failed-inputs '()))
(define (normalization-test-start name)
;(display ".")
(set! total-inputs (+ total-inputs 1))
(set! current-input name))
(define (failure-message-failed id ans correct)
(display "********** FAILURE *********") (newline)
(display " ") (display id) (display " did not pass test.")
(newline)
(display " Returned value = ") (display ans) (newline)
(display " Correct value = ") (display correct) (newline))
(define (normalization-test name predicate x y)
(set! total-tests (+ total-tests 1))
(if (not (predicate x y))
(begin (set! total-failed (+ total-failed 1))
(failure-message-failed name x y)
(if (or (null? failed-inputs)
(not (equal? current-input (car failed-inputs))))
(set! failed-inputs (cons current-input failed-inputs))))))
(define (normalization-test-summarize)
(newline)
(display "Failed ")
(write total-failed)
(display " out of ")
(write total-tests)
(newline))
(define (normalization-check-line s)
(call-with-values
(lambda ()
(parse-scalar-values s))
(lambda (c1 c2 c3 c4 c5)
(normalization-test-start s)
(normalization-check-one c1 c2 c3 c4 c5))))
(define (normalization-check-one c1 c2 c3 c4 c5)
(normalization-test "c2 == NFC(c1)" string=? c2 (string-normalize-nfc c1))
(normalization-test "c2 == NFC(c2)" string=? c2 (string-normalize-nfc c2))
(normalization-test "c2 == NFC(c3)" string=? c2 (string-normalize-nfc c3))
(normalization-test "c4 == NFC(c4)" string=? c4 (string-normalize-nfc c4))
(normalization-test "c4 == NFC(c5)" string=? c4 (string-normalize-nfc c5))
(normalization-test "c3 == NFD(c1)" string=? c3 (string-normalize-nfd c1))
(normalization-test "c3 == NFD(c2)" string=? c3 (string-normalize-nfd c2))
(normalization-test "c3 == NFD(c3)" string=? c3 (string-normalize-nfd c3))
(normalization-test "c5 == NFD(c4)" string=? c5 (string-normalize-nfd c4))
(normalization-test "c5 == NFD(c5)" string=? c5 (string-normalize-nfd c5))
(normalization-test "c4 == NFKC(c1)" string=? c4 (string-normalize-nfkc c1))
(normalization-test "c4 == NFKC(c2)" string=? c4 (string-normalize-nfkc c2))
(normalization-test "c4 == NFKC(c3)" string=? c4 (string-normalize-nfkc c3))
(normalization-test "c4 == NFKC(c4)" string=? c4 (string-normalize-nfkc c4))
(normalization-test "c4 == NFKC(c5)" string=? c4 (string-normalize-nfkc c5))
(normalization-test "c5 == NFKD(c1)" string=? c5 (string-normalize-nfkd c1))
(normalization-test "c5 == NFKD(c2)" string=? c5 (string-normalize-nfkd c2))
(normalization-test "c5 == NFKD(c3)" string=? c5 (string-normalize-nfkd c3))
(normalization-test "c5 == NFKD(c4)" string=? c5 (string-normalize-nfkd c4))
(normalization-test "c5 == NFKD(c5)" string=? c5 (string-normalize-nfkd c5)))
(define current-line "")
(define (normalization-check-all filename)
(call-with-input-file filename
(lambda (port)
(let loop ()
(let ((thing (get-line port)))
(set! current-line thing)
(if (string? thing)
(begin
(if (and (not (string=? "" thing))
(not (char=? (string-ref thing 0) #\#))
(not (char=? (string-ref thing 0) #\@)))
(normalization-check-line thing))
(loop))))))))
(define (run-normalization-tests input)
;(display "Normalization") (newline)
(normalization-test-init!)
(normalization-check-all input)
;(normalization-test-summarize)
(- total-tests (length failed-inputs)))
(define (main)
(let* ((count (read))
(input1 (read))
(output (read))
(s2 (number->string count))
(s1 input1)
(name "normalization"))
(run-r6rs-benchmark
(string-append name ":" s2)
count
(lambda () (run-normalization-tests (hide count input1)))
(lambda (result)
(and (null? failed-inputs)
(= result output))))))
| false |
4b0397825d4e62331efbca7f91ef17a2718d37cd
|
1059e93c74da454355afec71cac44efd72e34d6a
|
/High School/SmartBoard/anderson.ss
|
3a0d0aa905fea59bfebf1d4b1cd26149ca26f637
|
[] |
no_license
|
dyv/Programming
|
1ae7157585b57b7c8afa7f19a19601828c998639
|
0c8f377e1327c00828d358b112825015a2f8986d
|
refs/heads/master
| 2016-09-05T11:57:22.426496 | 2014-03-23T16:44:55 | 2014-03-23T16:44:55 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,297 |
ss
|
anderson.ss
|
#lang scheme
(require rnrs/eval-6)
;(require (lib "1.ss" "srfi")
; (lib "etc.ss"))
(require (only-in srfi/1 every))
(require (except-in scheme/gui/init
eval))
(require scheme/system)
(require (lib "process.ss"))
(require ffi/magick (for-syntax scheme/base))
;;;input and target sets for count-ones problem:
;(define-syntax (test stx)
; (syntax-case stx ()
; [(_ (func arg ...))
; (with-syntax ([(tmp ...) (generate-temporaries #'(arg ...))])
; #'(let ([tmp arg] ...)
; (let ([r (func tmp ...)])
; (printf " -> ~s\n" r)
; r)))]))
;; get-dimensions : string -> l
;(define (get-dimensions pic)
; (list (test (MagickGetImageWidth pic))
; (test (MagickGetImageHeight pic))))
;process-pic : pic -> list
(define (process-pic pic)
(letrec (
(bm (make-object bitmap% pic))
(dc (new bitmap-dc% (bitmap bm)))
(process-numbers
(lambda(pic)
(if (null? pic) '()
(cons (* 1/255 (car pic)) (process-numbers (cdr pic))))))
(getcolors
(lambda(pic)
(if (null? pic) '()
(cons (cadddr pic) (getcolors (drop pic 4))))))
;(slide (test (MagickReadImage pic)))
(dim '(24 15))
(pix (apply * (cons 4 dim))))
(let ((pixels (make-bytes pix)))
(begin
(send dc get-argb-pixels
0 0 (car dim) (cadr dim)
pixels)
(process-numbers (getcolors (bytes->list pixels)))))))
(define dataset (with-input-from-file "Input500new.txt" read))
(define input-set (map process-pic (map first dataset)))
;input-set
;input-set
"first"
;(caar input-set)
"second"
;(cadar input-set)
;sig : number -> number between 0 and 1
(define (sig total-input)
(/ 1.0 (+ 1.0 (exp (- 0 total-input)))))
;(sig 1) 0.731058446378433
;(sig -8)
;(sig 7)
(define output-set (map (lambda(r) (map (lambda(x)(sig (/ (- x 10) 3))) r)) (map cadr dataset)))
;(
; (eval (caar input-set)
; (environment '(rnrs))) (cadar input-set))
;process-row : listof(function args) -> output of function
(define (process-row r)
((eval (car r)
(environment '(rnrs)))(cadr input-set)))
"process-row"
(process-row (first input-set))
| true |
0671baa71f5ab49fb61f7df93c393735c1adf5f2
|
ece1c4300b543df96cd22f63f55c09143989549c
|
/Chapter2/Exercise 2.68.scm
|
70707a14a5ebaaf97d477fa8fa66f0c8041cd8b7
|
[] |
no_license
|
candlc/SICP
|
e23a38359bdb9f43d30715345fca4cb83a545267
|
1c6cbf5ecf6397eaeb990738a938d48c193af1bb
|
refs/heads/master
| 2022-03-04T02:55:33.594888 | 2019-11-04T09:11:34 | 2019-11-04T09:11:34 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,512 |
scm
|
Exercise 2.68.scm
|
; Exercise 2.68: The encode procedure takes as arguments a message and a tree and produces the list of bits that gives the encoded message.
; (define (encode message tree)
; (if (null? message)
; '()
; (append
; (encode-symbol (car message)
; tree)
; (encode (cdr message) tree))))
; Encode-symbol is a procedure, which you must write, that returns the list of bits that encodes a given symbol according to a given tree. You should design encode-symbol so that it signals an error if the symbol is not in the tree at all. Test your procedure by encoding the result you obtained in Exercise 2.67 with the sample tree and seeing whether it is the same as the original sample message.
(define (make-leaf symbol weight)
(list 'leaf symbol weight))
(define (leaf? object)
(eq? (car object) 'leaf))
(define (symbol-leaf x) (cadr x))
(define (weight-leaf x) (caddr x))
(define (left-branch tree) (car tree))
(define (right-branch tree) (cadr tree))
(define (symbols tree)
(if (leaf? tree)
(list (symbol-leaf tree))
(caddr tree)))
(define (weight tree)
(if (leaf? tree)
(weight-leaf tree)
(cadddr tree)))
(define (make-code-tree left right)
(list left
right
(append (symbols left)
(symbols right))
(+ (weight left) (weight right))))
(define (decode bits tree)
(define (decode-1 bits current-branch)
(if (null? bits)
'()
(let ((next-branch
(choose-branch
(car bits)
current-branch)))
(if (leaf? next-branch)
(cons
(symbol-leaf next-branch)
(decode-1 (cdr bits) tree))
(decode-1 (cdr bits)
next-branch)))))
(decode-1 bits tree))
(define (choose-branch bit branch)
(cond ((= bit 0) (left-branch branch))
((= bit 1) (right-branch branch))
(else (error "bad bit:
CHOOSE-BRANCH" bit))))
(define (encode message tree)
(if (null? message)
'()
(append
(encode-symbol (car message)
tree)
(encode (cdr message) tree))))
(define (element-of-set? x set)
(cond ((null? set) false)
((equal? x (car set)) true)
(else (element-of-set? x (cdr set)))))
(define (encode_symbol ele tree)
(if (leaf? tree)
nil
(let
(
(left (left-branch tree))
(right (right-branch tree))
)
(cond
((element-of-set? ele (symbols left)) (cons 0 (encode_symbol ele left)))
((element-of-set? ele (symbols right)) (cons 1 (encode_symbol ele right)))
(else (error "ele not found" ele))
)
)
)
)
(define sample-tree
(make-code-tree
(make-leaf 'A 4)
(make-code-tree
(make-leaf 'B 2)
(make-code-tree
(make-leaf 'D 1)
(make-leaf 'C 1)))))
(define sample-message
'(0 1 1 0 0 1 0 1 0 1 1 1 0))
(display (encode_symbol 'A sample-tree))(newline)
(display (encode_symbol 'B sample-tree))(newline)
(display (encode_symbol 'C sample-tree))(newline)
(display (encode_symbol 'D sample-tree))(newline)
(define a (decode sample-message sample-tree))
(display (encode a sample-tree))
; Welcome to DrRacket, version 6.7 [3m].
; Language: SICP (PLaneT 1.18); memory limit: 128 MB.
; (0)
; (1 0)
; (1 1 1)
; (1 1 0)
; (0 1 1 0 0 1 0 1 0 1 1 1 0)
; >
| false |
9f4a01a251bd00dadf49c54d8fdc92865dcfa2be
|
ac2a3544b88444eabf12b68a9bce08941cd62581
|
/tests/unit-tests/02-flonum/flcosh.scm
|
1f266b14f2147f4bd191668e6940927ac1439f75
|
[
"Apache-2.0",
"LGPL-2.1-only"
] |
permissive
|
tomelam/gambit
|
2fd664cf6ea68859d4549fdda62d31a25b2d6c6f
|
d60fdeb136b2ed89b75da5bfa8011aa334b29020
|
refs/heads/master
| 2020-11-27T06:39:26.718179 | 2019-12-15T16:56:31 | 2019-12-15T16:56:31 | 229,341,552 | 1 | 0 |
Apache-2.0
| 2019-12-20T21:52:26 | 2019-12-20T21:52:26 | null |
UTF-8
|
Scheme
| false | false | 311 |
scm
|
flcosh.scm
|
(include "#.scm")
(check-= (flcosh 0.) (flcosh-144 0.))
(check-= (flcosh 0.5) (flcosh-144 0.5))
(check-= (flcosh -0.5) (flcosh-144 -0.5))
(check-tail-exn type-exception? (lambda () (flcosh 0)))
(check-tail-exn type-exception? (lambda () (flcosh 1/2)))
(check-tail-exn type-exception? (lambda () (flcosh 'a)))
| false |
4da06dcede7d2cabca388ea1159b8040d448d068
|
a6a1c8eb973242fd2345878e5a871a89468d4080
|
/3.69.scm
|
f0b35dba08ef10006851e19afbcb7a4bb9091cac
|
[] |
no_license
|
takkyuuplayer/sicp
|
ec20b6942a44e48d559e272b07dc8202dbb1845a
|
37aa04ce141530e6c9803c3c7122016d432e924b
|
refs/heads/master
| 2021-01-17T07:43:14.026547 | 2017-02-22T03:40:07 | 2017-02-22T03:40:07 | 15,771,479 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,353 |
scm
|
3.69.scm
|
(load "./lib/stream/base.scm")
(load "./lib/stream/list.scm")
(load "./lib/stream/calc.scm")
(load "./lib/stream/display.scm")
(define ones (cons-stream 1 ones))
(define integers (cons-stream 1 (add-streams ones integers)))
(define (interleave s1 s2)
(if (stream-null? s1)
s2
(cons-stream (stream-car s1)
(interleave s2 (stream-cdr s1)))))
(define (pairs s t)
(cons-stream
(list (stream-car s) (stream-car t))
(interleave
(stream-map (lambda (x) (list (stream-car s) x))
(stream-cdr t))
(pairs (stream-cdr s) (stream-cdr t)))))
; 3.69
(define (triples s t u)
(cons-stream
(list (stream-car s) (stream-car t) (stream-car u))
(interleave
(stream-map (lambda (x) (append (list (stream-car s)) x)) (pairs t (stream-cdr u)))
(triples (stream-cdr s) (stream-cdr t) (stream-cdr u))
)
))
(stream-head (triples integers integers integers) 10)
(define pythagoras (stream-filter
(lambda (x) (let ((a (car x))
(b (cadr x))
(c (caddr x)))
(= (+ (* a a) (* b b)) (* c c))
))
(triples integers integers integers)
)
)
(stream-head pythagoras 4)
| false |
bb5f413c4c1e497c149ffcd668c6547a9819e3f6
|
370ebaf71b077579ebfc4d97309ce879f97335f7
|
/sicp/tests/ch2/rectangleTests.scm
|
00455f6f96cb89e327230f8668030a85e114014f
|
[] |
no_license
|
jgonis/sicp
|
7f14beb5b65890a86892a05ba9e7c59fc8bceb80
|
fd46c80b98c408e3fd18589072f02ba444d35f53
|
refs/heads/master
| 2023-08-17T11:52:23.344606 | 2023-08-13T22:20:42 | 2023-08-13T22:20:42 | 376,708,557 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,863 |
scm
|
rectangleTests.scm
|
(define-library (tests ch2 rectangleTests)
(export rectangle-tests)
(import (scheme base)
(scheme write)
(ch2 point)
(ch2 rectangle)
(ch2 rectangleFunctions)
(srfi 64))
(begin
(define rectangle-tests
(lambda ()
(rectangle-equal-tests)
(rectangle-area-tests)
(rectangle-perimeter-tests)
(rectangle-error-tests)
;;If using Gauche scheme, uncomment this line to avoid the
;;test count continuing to increase
(test-runner-reset (test-runner-current))))
(define (rectangle-equal-tests)
(test-begin "rectangle-equal-tests")
(let ((rect1 (make-rectangle (make-point 0 0) 5 5))
(rect2 (make-rectangle (make-point 0 0) 5 5))
(rect3 (make-rectangle (make-point 0 0) 4 4)))
(test-assert (equal-rectangle rect1 rect2))
(test-assert (equal-rectangle rect2 rect1))
(test-assert (not (equal-rectangle rect2 rect3)))
(test-assert (not (equal-rectangle rect3 rect2))))
(test-end "rectangle-equal-tests"))
(define (rectangle-area-tests)
(test-begin "rectangle-area-tests")
(let ((rect1 (make-rectangle (make-point 0 0) 5 5)))
(test-equal 25 (rectangle-area rect1)))
(test-end "rectangle-area-tests"))
(define (rectangle-perimeter-tests)
(test-begin "rectangle-perimeter-tests")
(let ((rect1 (make-rectangle (make-point 0 0) 5 5))
(rect2 (make-rectangle (make-point 0 0) 4 5)))
(test-equal 20 (rectangle-perimeter rect1))
(test-equal 18 (rectangle-perimeter rect2)))
(test-end "rectangle-perimeter-tests"))
(define (rectangle-error-tests)
(test-begin "rectangle-error-tests")
(test-error (make-rectangle (make-point 0 0) -1 5))
(test-error (make-rectangle (make-point 0 0) 1 -5))
(test-error (make-rectangle (make-point 0 0) -1 -5))
(test-end "rectangle-error-tests"))))
| false |
1469525fc84ba07908902c0f60f2ca98622aac5e
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine.UI/unity-engine/event-systems/touch-input-module.sls
|
8f4b6be6ce584ed9b398b89b0f7f0b126e5c857a
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,617 |
sls
|
touch-input-module.sls
|
(library (unity-engine event-systems touch-input-module)
(export is?
touch-input-module?
deactivate-module
is-module-supported?
should-activate-module?
update-module
process
to-string
allow-activation-on-standalone?-get
allow-activation-on-standalone?-set!
allow-activation-on-standalone?-update!)
(import (ironscheme-clr-port))
(define (is? a) (clr-is UnityEngine.EventSystems.TouchInputModule a))
(define (touch-input-module? a)
(clr-is UnityEngine.EventSystems.TouchInputModule a))
(define-method-port
deactivate-module
UnityEngine.EventSystems.TouchInputModule
DeactivateModule
(System.Void))
(define-method-port
is-module-supported?
UnityEngine.EventSystems.TouchInputModule
IsModuleSupported
(System.Boolean))
(define-method-port
should-activate-module?
UnityEngine.EventSystems.TouchInputModule
ShouldActivateModule
(System.Boolean))
(define-method-port
update-module
UnityEngine.EventSystems.TouchInputModule
UpdateModule
(System.Void))
(define-method-port
process
UnityEngine.EventSystems.TouchInputModule
Process
(System.Void))
(define-method-port
to-string
UnityEngine.EventSystems.TouchInputModule
ToString
(System.String))
(define-field-port
allow-activation-on-standalone?-get
allow-activation-on-standalone?-set!
allow-activation-on-standalone?-update!
(property:)
UnityEngine.EventSystems.TouchInputModule
allowActivationOnStandalone
System.Boolean))
| false |
29b5577d7fbf9b73a7df38d6063a7d9c115b5239
|
9fe2d608e47449b54fb1e35a9b671ba646fbe57c
|
/Mines Courses/CSCI_400/SlytherLisp/examples/triangle.scm
|
241f151b9acf08498b6adbe0f53b388ccf35eb3f
|
[] |
no_license
|
CarsonStevens/Mines-Courses
|
4ab0e4ef2fe54bdf799eef8a089a1cd980ef5772
|
1328e882e52d9eecfebc23e98cee41f49b8615dd
|
refs/heads/master
| 2021-06-07T10:39:59.126121 | 2021-05-30T17:37:31 | 2021-05-30T17:37:31 | 164,183,386 | 5 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 293 |
scm
|
triangle.scm
|
#!/usr/bin/env slyther
(define base (make-float
(input "What is the length of the base of your triangle? ")))
(define height (make-float
(input "What is the height of your triangle? ")))
(print "The area is" (/ (* base height) 2))
(print "Have a great day!")
| false |
784046c100c4913c8fe9ce52cc02036356873862
|
eef5f68873f7d5658c7c500846ce7752a6f45f69
|
/test/structure-lru-cache.scm
|
cadea53375aac0bb2938bd1aee1917f855e7aee8
|
[
"MIT"
] |
permissive
|
alvatar/spheres
|
c0601a157ddce270c06b7b58473b20b7417a08d9
|
568836f234a469ef70c69f4a2d9b56d41c3fc5bd
|
refs/heads/master
| 2021-06-01T15:59:32.277602 | 2021-03-18T21:21:43 | 2021-03-18T21:21:43 | 25,094,121 | 13 | 3 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 682 |
scm
|
structure-lru-cache.scm
|
(define C (make-lru-cache 4 string=?
(lambda (k v) (println "deleting " k v))))
(lru-cache-set! C "a" 1) ; a
(lru-cache-set! C "b" 2) ; b a
(lru-cache-set! C "c" 3) ; c b a
(lru-cache-set! C "d" 4) ; d c b a
(lru-cache-walk C println)
;; d4
;; c3
;; b2
;; a1
(lru-cache-set! C "e" 5) ; e d c b
;; deleting (a 1)
(lru-cache-ref C "b") ; 2, b e d c
(lru-cache-ref C "d") ; 4, d b e c
(lru-cache-walk C println)
;; d4
;; b2
;; e5
;; c3
(lru-cache-delete! C "e") ; d b c
;; deleting ("e" 5)
(lru-cache-set! C "a" 6) ; a d b c
(lru-cache-flush! C)
;; deleting ("a" 6)
;; deleting ("d" 4)
;; deleting ("b" 2)
;; deleting ("c" 3)
(lru-cache-walk C println)
| false |
45cec7020b3c2aacd4c0b883c428c06a856061e9
|
54f854ff6b6725cab04dd3e1a3efff518e098ad3
|
/assets/set-construct.scm
|
11cfa5fef6f8998af66230844f93083045d94073
|
[
"MIT"
] |
permissive
|
Vanille-N/rask
|
679172799c8cafcc3d280de39b9d6b5246efe973
|
680307d80796bfbf3e5e4d8ee82ec27d7ffdc76c
|
refs/heads/master
| 2022-12-01T23:27:41.540739 | 2020-08-13T08:27:37 | 2020-08-13T08:27:37 | 269,349,976 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,323 |
scm
|
set-construct.scm
|
(library (tspl sets)
(export set-of set-cons in is)
(import (rnrs))
; set-of uses helper syntactic extension set-of-help, passing it
; an initial base expression of '()
(define-syntax set-of
(syntax-rules ()
[(_ e m ...)
(set-of-help e '() m ...)]))
; set-of-help recognizes in, is, and predicate expressions and
; changes them into nested named let, let, and if expressions.
(define-syntax set-of-help
(syntax-rules (in is)
[(_ e base) (set-cons e base)]
[(_ e base (x in s) m ...)
(let loop ([set s])
(if (null? set)
base
(let ([x (car set)])
(set-of-help e (loop (cdr set)) m ...))))]
[(_ e base (x is y) m ...)
(let ([x y]) (set-of-help e base m ...))]
[(_ e base p m ...)
(if p (set-of-help e base m ...) base)]))
; since in and is are used as auxiliary keywords by set-of, the
; library must export definitions for them as well
(define-syntax in
(lambda (x)
(syntax-violation 'in "misplaced auxiliary keyword" x)))
(define-syntax is
(lambda (x)
(syntax-violation 'is "misplaced auxiliary keyword" x)))
; set-cons returns the original set y if x is already in y.
(define set-cons
(lambda (x y)
(if (memv x y)
y
(cons x y)))))
| true |
197c0f84c077cfe14f5aa32e1510f744fcc48550
|
b14c18fa7a4067706bd19df10f846fce5a24c169
|
/Chapter1/1.20.scm
|
fdb995165df8c7c4c21678e3cafd0ced2e601369
|
[] |
no_license
|
silvesthu/LearningSICP
|
eceed6267c349ff143506b28cf27c8be07e28ee9
|
b5738f7a22c9e7967a1c8f0b1b9a180210051397
|
refs/heads/master
| 2021-01-17T00:30:29.035210 | 2016-11-29T17:57:16 | 2016-11-29T17:57:16 | 19,287,764 | 3 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,241 |
scm
|
1.20.scm
|
#lang scheme
(define (gcd a b)
(if (= b 0)
a
(gcd b (remainder a b))))
(gcd 206 40)
; normal-order
; l0: gcd 206 40
; l1: gcd 40 (remainder 206 40), let P0 = (remainder 206 40) = 6
; l2: if P0, gcd P0 (remainder 40 P0), let P1 = (remainder 40 P0) = 4
; l3: if P1, gcd P1 (remainder P0 P1) let P2 = (remainder P0 P1) = 2
; l4: if P2, gcd P2 (remainder P1 P2) let P3 = (remainder P1 P2) = 0
; l5: if P3, <<< evaluate end, gcd P3 (remainder P2 P3)
(if (= (remainder (remainder 40 (remainder 206 40)) (remainder (remainder 206 40) (remainder 40 (remainder 206 40)))) 0)
(remainder (remainder 206 40) (remainder 40 (remainder 206 40)))
; the code below will not be evalutated
(gcd (remainder (remainder 40 (remainder 206 40)) (remainder (remainder 206 40) (remainder 40 (remainder 206 40)))) (remainder (remainder (remainder 206 40) (remainder 40 (remainder 206 40))) (remainder (remainder 40 (remainder 206 40)) (remainder (remainder 206 40) (remainder 40 (remainder 206 40)))))))
; Total
; 11 times of remainder evaluation
; -------------------
; applicative-order
; gcd 206 40
; gcd 40 (remainder 206 40)
; gcd 6 (remainder 40 6)
; gcd 4 (remainder 6 4)
; gcd 2 (remainder 4 2)
; end
; Total
; 4 times of remainder evaluation
| false |
08c4b86e2ac9211769583041b9efec5f06b4a25a
|
98867a6625fc664d0dafa0668dc8f1d507a071e2
|
/scheme/game/object.scm
|
64039bdb046e397b168a5de77e9dcb79cac9e2ab
|
[
"ISC"
] |
permissive
|
tekktonic/programming
|
4b81efc115108bfdfc4a70a0d3b9157c1b91c8c0
|
139959ab9934912d4c531e5ee8b1f39094a6823c
|
refs/heads/master
| 2021-05-11T03:24:47.507478 | 2018-01-18T01:16:38 | 2018-01-18T01:16:38 | 80,262,894 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 50 |
scm
|
object.scm
|
;this is a pure interface
(define-generic delete)
| false |
1beea281b832712dff951891fd01a6e4c3007474
|
18e69f3b8697cebeccdcd7585fcfc50a57671e21
|
/scheme/hash.scm
|
7305845469fc9a8195eb7a4ea49ea86a40e2a126
|
[] |
no_license
|
ashikawa/scripts
|
694528ccfd0b84edaa980d6cde156cfe394fe98a
|
c54463b736c6c01781a0bfe00472acd32f668550
|
refs/heads/master
| 2021-01-25T04:01:34.073018 | 2013-12-02T03:33:29 | 2013-12-02T03:33:29 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 444 |
scm
|
hash.scm
|
(define (fact n)
(fact2 n 1))
(define (fact2 n m)
(if (< n (+ m 1))
1
(* n (fact2 (- n 1) m))))
(define (pow x n)
(if (> n 1)
(* x (pow x (- n 1)))
x))
(define (per num n)
(- 1 (/ (fact num) (* (pow num n) (fact (- num n))))))
(define (per2 num n)
(- 1 (/ (fact2 num n) (pow num n))))
(define num 365)
(define n 23)
;(display (exact->inexact (per num n)))
;(newline)
;(display (exact->inexact (per2 num n)))
;(newline)
| false |
2bca377d93b438b9e008c9c4f7c75177f08cc0b0
|
c39d4eda6c001b3aa98789232f9ce422369ece8e
|
/letrec-issue.scm
|
7c6dbf9a5740a6b950955aa1531e84db3677158c
|
[] |
no_license
|
namin/staged-miniKanren
|
43477369ab2150a6f26222b1b50ab008fb64f15a
|
af986fd3e8facf83d21db41826e4609b0d45e32d
|
refs/heads/master
| 2023-08-31T23:45:51.352139 | 2022-02-27T18:35:35 | 2022-02-27T18:35:35 | 109,611,513 | 115 | 16 | null | 2021-07-08T18:05:27 | 2017-11-05T19:59:39 |
Scheme
|
UTF-8
|
Scheme
| false | false | 1,539 |
scm
|
letrec-issue.scm
|
(test
(run 1 (q)
(fresh (v)
(u-eval-expo
'(f 1)
`((f . (val . ,v)) . ,initial-env)
1)
(u-eval-expo
`(lambda (x) ,q)
initial-env
v)))
'(1))
(test
(run-staged 1 (q)
(fresh (v)
(later `(u-eval-expo
'(f 1)
`((f . (val . ,,(expand v))) . ,initial-env)
1))
(eval-expo
#t
`(lambda (x) ,q)
initial-env
v)))
'(1))
(test
(run 1 (q)
(fresh (v)
(u-eval-expo
'(f 1)
`((f . (val . ,v)) . ,initial-env)
1)
(u-eval-expo
`(letrec ([g (lambda (x) ,q)]) g)
initial-env
v)))
'(1))
#|
(run-staged 1 (q)
(fresh (v)
(later `(u-eval-expo
'(f 1)
`((f . (val . ,,(expand v))) . ,initial-env)
1))
(eval-expo
#t
`(letrec ([g (lambda (x) ,q)]) g)
initial-env
v)))
divergence
This happens because the closure created by the first eval running backwards cannot unify with the representation of letrec-defined functions from the staged interpreter.
|#
;; this works
(run-staged 1 (q)
(evalo-staged
`(letrec ((id (lambda (x) x)))
((lambda (f) ,q) id))
1)
;; strange when commenting this out
;;(l== q `(f 1))
)
;; letrec mutual recursion not compatible with env lookup in unstaged interp.
(run 1 (q)
(evalo-staged
`(letrec ((f (lambda (x) ,q))
(g (lambda (x) x)))
1)
1))
| false |
c7d94d3e0e39a3a49b79db76918eecb2631a7a36
|
784dc416df1855cfc41e9efb69637c19a08dca68
|
/src/std/pregexp.ss
|
58a21f84282c73fc9ac90d99f85347d2c383d788
|
[
"LGPL-2.1-only",
"Apache-2.0",
"LGPL-2.1-or-later"
] |
permissive
|
danielsz/gerbil
|
3597284aa0905b35fe17f105cde04cbb79f1eec1
|
e20e839e22746175f0473e7414135cec927e10b2
|
refs/heads/master
| 2021-01-25T09:44:28.876814 | 2018-03-26T21:59:32 | 2018-03-26T21:59:32 | 123,315,616 | 0 | 0 |
Apache-2.0
| 2018-02-28T17:02:28 | 2018-02-28T17:02:28 | null |
UTF-8
|
Scheme
| false | false | 324 |
ss
|
pregexp.ss
|
;;; -*- Gerbil -*-
;;; (C) vyzo at hackzen.org
;;; Dorai Sitaram's pregexp, slightly modified
package: std
(declare (fixnum))
(export pregexp
pregexp-match-positions
pregexp-match
pregexp-split
pregexp-replace
pregexp-replace*
pregexp-quote)
(include "pregexp/pregexp.scm")
| false |
f161f8fa194815f2d2db6517f0bcd3bc4e95985b
|
ec0f122fdcf4ceaf5e9e183575a460006c19ebe0
|
/src/sections/awana-structure.data.scm
|
87127851fecffb4eac4fd0c6cc47a6cbc680b21e
|
[] |
no_license
|
ThomasHintz/keep-the-records
|
d96e6253ebc3d2e11ee37277a6293c7365b25f9b
|
c20e648e831bed2ced3f2f74bfc590dc06b5f076
|
refs/heads/master
| 2021-01-13T02:37:41.053488 | 2013-07-19T04:18:44 | 2013-07-19T04:18:44 | 1,272,038 | 2 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,674 |
scm
|
awana-structure.data.scm
|
`("Awana Data" (("Cubbies" (("Hopper" (("Bear Hug Brochure" ("1" "2"))
("Hopper Trail" ("1" "2"))
("Lamb Path 1" ("1" "2"))
("Elephant Walk 1" ("1" "2"))
("Lamb Path 2" ,(srange 1 4))
("Elephant Walk 2" ,(srange 1 4))
("Lamb Path 3" ,(srange 1 4))
("Elephant Walk 3" ,(srange 1 4))
("Lamb Path 4" ,(srange 1 4))
("Elephant Walk 4" ,(srange 1 4))
("Under the Apple Tree" ,(srange 1 25))
("Character Builder" ,(srange 1 21))
("Special Hugs" ,(srange 1 7))))
("Jumper" (("Bear Hug Brochure" ("1" "2"))
("Jumper Trail" ("1" "2"))
("Lamb Path 1" ("1" "2"))
("Elephant Walk 1" ("1" "2"))
("Lamb Path 2" ,(srange 1 4))
("Elephant Walk 2" ,(srange 1 4))
("Lamb Path 3" ,(srange 1 4))
("Elephant Walk 3" ,(srange 1 4))
("Lamb Path 4" ,(srange 1 4))
("Elephant Walk 4" ,(srange 1 4))
("Under the Apple Tree" ,(srange 1 25))
("Character Builder" ,(srange 1 21))
("Special Hugs" ,(srange 1 7))))))
("Sparks" (("Flight 3:16" (("Flight 3:16" ,(srange 1 7))))
("HangGlider" (("HangGlider Rank" ,(srange 1 9))
("Red Jewel 1" ,(srange 1 5))
("Green Jewel 1" ,(srange 1 5))
("Red Jewel 2" ,(srange 1 5))
("Green Jewel 2" ,(srange 1 5))
("Red Jewel 3" ,(srange 1 5))
("Green Jewel 3" ,(srange 1 5))
("Red Jewel 4" ,(srange 1 5))
("Green Jewel 4" ,(srange 1 5))
("Review HangGlider Rank" ("1" "3" "4" "5" "6" "7"))
("Review Red Jewel 1" ("2" "3" "4"))
("Review Green Jewel 1" ("2" "3" "4"))
("Review Red Jewel 2" ("2" "3" "4"))
("Review Green Jewel 2" ("4"))
("Review Green Jewel 3" ("1"))
("Review Red Jewel 4" ("2" "3" "4"))
("Review Green Jewel 4" ("2"))
("Return Flight" ,(srange 1 16))
("Takeoff" ,(srange 1 6))
("Passport" ,(srange 1 6))
("Passenger List" ,(srange 1 6))
("Landing Gear" ,(srange 1 6))))
("WingRunner" (("WingRunner Rank" ,(srange 1 9))
("Red Jewel 1" ,(srange 1 5))
("Green Jewel 1" ,(srange 1 5))
("Red Jewel 2" ,(srange 1 5))
("Green Jewel 2" ,(srange 1 5))
("Red Jewel 3" ,(srange 1 5))
("Green Jewel 3" ,(srange 1 5))
("Red Jewel 4" ,(srange 1 5))
("Green Jewel 4" ,(srange 1 5))
("Review WingRunner Rank" ,(append (srange 1 7)) '("8"))
("Review Red Jewel 1" ("2" "3" "4"))
("Review Green Jewel 1" ("1" "2" "3"))
("Review Red Jewel 2" ("3"))
("Review Green Jewel 2" ("3" "4"))
("Review Green Jewel 3" ("4"))
("Review Red Jewel 4" ,(srange 1 5))
("Review Green Jewel 4" ("1" "2"))
("Return Flight" ,(srange 1 16))
("Takeoff" ,(srange 1 6))
("Passport" ,(srange 1 6))
("Passenger List" ,(srange 1 6))
("Landing Gear" ,(srange 1 6))))
("SkyStormer" (("SkyStormer Rank" ,(srange 1 9))
("Red Jewel 1" ,(srange 1 5))
("Green Jewel 1" ,(srange 1 5))
("Red Jewel 2" ,(srange 1 5))
("Green Jewel 2" ,(srange 1 5))
("Red Jewel 3" ,(srange 1 5))
("Green Jewel 3" ,(srange 1 5))
("Red Jewel 4" ,(srange 1 5))
("Green Jewel 4" ,(srange 1 5))
("Review SkyStormer Rank" ,(srange 1 8))
("Review Red Jewel 1" ,(srange 1 5))
("Review Green Jewel 1" ,(srange 1 5))
("Review Red Jewel 2" ,(srange 1 5))
("Review Green Jewel 2" ,(srange 1 5))
("Review Red Jewel 3" ,(srange 1 5))
("Review Green Jewel 3" ,(srange 1 5))
("Review Red Jewel 4" ,(srange 1 5))
("Review Green Jewel 4" ,(srange 1 5))
("Return Flight" ,(srange 1 16))
("Takeoff" ,(srange 1 6))
("Passport" ,(srange 1 6))
("Passenger List" ,(srange 1 6))
("Landing Gear" ,(srange 1 6))))))
("TnT" ,(cons `("Start Zone" (("Start Zone" ,(srange 1 8))))
(map (lambda (book-n)
`(,(string-append "Book " (number->string book-n))
,(append (map (lambda (discovery-n)
`(,(string-append "Discovery " (number->string discovery-n)) ,(map (lambda (e) (number->string e)) (range 1 8))))
(range 1 9))
(map (lambda (silver-n)
`(,(string-append "Silver " (number->string silver-n)) ("1")))
(range 1 9))
(map (lambda (gold-n)
`(,(string-append "Gold " (number->string gold-n)) ("1" "2")))
(range 1 9)))))
(range 1 5))))
))
| false |
14f236901b69398329f53930b6e76eb95889034f
|
6438e08dfc709754e64a4d8e962c422607e5ed3e
|
/scheme/scene/scene3.scm
|
498bed4d174886b3118bbc6bdf85fbeb1e8bcf31
|
[] |
no_license
|
HugoNikanor/GuileGamesh
|
42043183167cdc9d45b4dc626266750aecbee4ff
|
77d1be4a20b3f5b9ff8f18086bf6394990017f23
|
refs/heads/master
| 2018-10-13T10:54:00.134522 | 2018-07-11T19:45:15 | 2018-07-11T19:45:15 | 110,285,413 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 796 |
scm
|
scene3.scm
|
(define-module (scene scene3)
#:use-module (oop goops)
#:use-module (engine)
#:use-module (scene)
#:use-module (objects sprite)
#:use-module (arrowcontrol)
#:use-module (util)
#:use-module (vector)
#:use-module (objects swap-sprite)
#:export (scene3 s1 ss))
(with-new-scene scene3 "SCENE 3"
;;
(define-class <ctrl-spr> (<sprite> <arrow-control>))
(define-once s1 (make <ctrl-spr>))
(define-once ss (make <swap-sprite>
#:name "Swap Sprite"
#:pos (v2 1 1)
#:file "assets/PathAndObjects_0.png"
#:size (v2 16 16)
#:amount (v2 10 10)
))
(do-once
(register-draw-object! s1)
(register-tick-object! s1)
(register-draw-object! ss)
))
| false |
ef2f911131932b2eb6215b6ca397ca81b8d94221
|
d63c4c79d0bf83ae646d0ac023ee0528a0f4a879
|
/cs133/assn9/a9q4.scm
|
2d58b03d2502e57b60af4fb0312108524be2c82f
|
[] |
no_license
|
stratigoster/UW
|
4dc31f08f7f1c9a958301105dcad481c39c5361f
|
7a4bff4f1476607c43278c488f70d01077b1566b
|
refs/heads/master
| 2021-07-07T04:52:01.543221 | 2011-08-15T05:08:48 | 2011-08-15T05:08:48 | 10,858,995 | 1 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 902 |
scm
|
a9q4.scm
|
(define (remove-duplicates somelist)
;; acc is the output list with all elements in somelist encountered so far, minus those that are duplicates.
(local ((define (remove somelist acc)
(cond
[(empty? somelist) acc]
[else
(cond
[(boolean? (member (first somelist) (rest somelist))) (remove (rest somelist) (cons (first somelist) acc))]
[else (remove (rest somelist) acc)])])))
(remove (reverse somelist) empty)))
;; testing remove-duplicates
;; 1.
(equal? (remove-duplicates empty) empty)
;; 2.
(equal? (remove-duplicates '(1)) '(1))
;; 3.
(equal? (remove-duplicates '(1 1)) '(1))
;; 4.
(equal? (remove-duplicates '(1 2 3 1)) '(1 2 3))
;; 5.
(equal? (remove-duplicates '(1 2 3 2 3 4 1 9 8 9 3)) '(1 2 3 4 9 8))
;; 6.
(equal? (remove-duplicates '(1 4 2 1 5 4)) '(1 4 2 5))
| false |
c17a93d7604d3eac57ec2f80c7a433b1561da015
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/display.sls
|
8660cb56a185cdc210f920072050c28ea3312e0f
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 2,364 |
sls
|
display.sls
|
(library (unity-engine display)
(export is?
display?
multi-display-license?
relative-mouse-at
set-rendering-resolution
activate
set-params
displays-get
displays-set!
displays-update!
rendering-width
rendering-height
system-width
system-height
color-buffer
depth-buffer
main)
(import (ironscheme-clr-port))
(define (is? a) (clr-is UnityEngine.Display a))
(define (display? a) (clr-is UnityEngine.Display a))
(define-method-port
multi-display-license?
UnityEngine.Display
MultiDisplayLicense
(static: System.Boolean))
(define-method-port
relative-mouse-at
UnityEngine.Display
RelativeMouseAt
(static: UnityEngine.Vector3 UnityEngine.Vector3))
(define-method-port
set-rendering-resolution
UnityEngine.Display
SetRenderingResolution
(System.Void System.Int32 System.Int32))
(define-method-port
activate
UnityEngine.Display
Activate
(System.Void System.Int32 System.Int32 System.Int32)
(System.Void))
(define-method-port
set-params
UnityEngine.Display
SetParams
(System.Void System.Int32 System.Int32 System.Int32 System.Int32))
(define-field-port
displays-get
displays-set!
displays-update!
(static:)
UnityEngine.Display
displays
UnityEngine.Display[])
(define-field-port
rendering-width
#f
#f
(property:)
UnityEngine.Display
renderingWidth
System.Int32)
(define-field-port
rendering-height
#f
#f
(property:)
UnityEngine.Display
renderingHeight
System.Int32)
(define-field-port
system-width
#f
#f
(property:)
UnityEngine.Display
systemWidth
System.Int32)
(define-field-port
system-height
#f
#f
(property:)
UnityEngine.Display
systemHeight
System.Int32)
(define-field-port
color-buffer
#f
#f
(property:)
UnityEngine.Display
colorBuffer
UnityEngine.RenderBuffer)
(define-field-port
depth-buffer
#f
#f
(property:)
UnityEngine.Display
depthBuffer
UnityEngine.RenderBuffer)
(define-field-port
main
#f
#f
(static: property:)
UnityEngine.Display
main
UnityEngine.Display))
| false |
c12338eaff3a692c17eb0c8b7ab6ef6c7b7294b4
|
4f17c70ae149426a60a9278c132d5be187329422
|
/scheme/refimpl/arithmetic/impl/bitwise.sls
|
39533af208297e48b39bd154317b12332eaec9b1
|
[
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"BSD-2-Clause"
] |
permissive
|
okuoku/yuni-core
|
8da5e60b2538c79ae0f9d3836740c54d904e0da4
|
c709d7967bcf856bdbfa637f771652feb1d92625
|
refs/heads/master
| 2020-04-05T23:41:09.435685 | 2011-01-12T15:54:23 | 2011-01-12T15:54:23 | 889,749 | 2 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,979 |
sls
|
bitwise.sls
|
;; bitwise-arithmetic took from r5rs.sch
(library (yuni scheme refimpl arithmetic impl bitwise)
(export arithmetic-shift
bitwise-and
bitwise-ior
bitwise-xor
bitwise-not
bit-count)
(import (yuni scheme refimpl arithmetic backend))
; This file is part of the reference implementation of the R6RS Arithmetic SRFI.
; See file COPYING.
; Code for loading and testing the reference implementation into
; R5RS-conforming implementations of Scheme that provide flonum
; arithmetic and exact integer arithmetic over [-2^23, 2^23-1].
;
; Before loading this file, any inlining of R5RS arithmetic
; procedures must be disabled, and SRFI 9 (Defining Record
; Types) and SRFI 23 (Error reporting mechanism) must be
; enabled.
; Define a small set of bitwise operators.
; The core: procedures will be loaded soon afterwards.
; Given exact integers n and k, with k >= 0, return (* n (expt 2 k)).
(define (arithmetic-shift n k)
(if (and (core:exact? n)
(core:integer? n)
(core:exact? k)
(core:integer? k))
(cond ((core:> k 0)
(core:* n (core:expt 2 k)))
((core:= k 0)
n)
((core:>= n 0)
(core:quotient n (core:expt 2 (core:- k))))
(else
(let* ((q (core:expt 2 (core:- k)))
(p (core:quotient (core:- n) q)))
(if (core:= n (core:* p k))
(core:- p)
(core:- -1 p)))))
(error "illegal argument to arithmetic-shift" n k)))
; Bitwise operations on exact integers.
(define (bitwise-and i j)
(if (and (core:exact? i)
(core:integer? i)
(core:exact? j)
(core:integer? j))
(cond ((or (core:= i 0) (core:= j 0))
0)
((core:= i -1)
j)
((core:= j -1)
i)
(else
(let* ((i0 (if (core:odd? i) 1 0))
(j0 (if (core:odd? j) 1 0))
(i1 (core:- i i0))
(j1 (core:- j j0))
(i/2 (core:quotient i1 2))
(j/2 (core:quotient j1 2))
(hi (core:* 2 (bitwise-and i/2 j/2)))
(lo (core:* i0 j0)))
(core:+ hi lo))))
(error "illegal argument to bitwise-and" i j)))
(define (bitwise-ior i j)
(if (and (core:exact? i)
(core:integer? i)
(core:exact? j)
(core:integer? j))
(cond ((or (core:= i -1) (core:= j -1))
-1)
((core:= i 0)
j)
((core:= j 0)
i)
(else
(let* ((i0 (if (core:odd? i) 1 0))
(j0 (if (core:odd? j) 1 0))
(i1 (core:- i i0))
(j1 (core:- j j0))
(i/2 (core:quotient i1 2))
(j/2 (core:quotient j1 2))
(hi (core:* 2 (bitwise-ior i/2 j/2)))
(lo (if (core:= 0 (core:+ i0 j0)) 0 1)))
(core:+ hi lo))))
(error "illegal argument to bitwise-ior" i j)))
(define (bitwise-xor i j)
(if (and (core:exact? i)
(core:integer? i)
(core:exact? j)
(core:integer? j))
(cond ((and (core:= i -1) (core:= j -1))
0)
((core:= i 0)
j)
((core:= j 0)
i)
(else
(let* ((i0 (if (core:odd? i) 1 0))
(j0 (if (core:odd? j) 1 0))
(i1 (core:- i i0))
(j1 (core:- j j0))
(i/2 (core:quotient i1 2))
(j/2 (core:quotient j1 2))
(hi (core:* 2 (bitwise-xor i/2 j/2)))
(lo (if (core:= 1 (core:+ i0 j0)) 1 0)))
(core:+ hi lo))))
(error "illegal argument to bitwise-xor" i j)))
(define (bitwise-not i)
(if (and (core:exact? i)
(core:integer? i))
(cond ((core:= i -1)
0)
((core:= i 0)
-1)
(else
(let* ((i0 (if (core:odd? i) 1 0))
(i1 (core:- i i0))
(i/2 (core:quotient i1 2))
(hi (core:* 2 (bitwise-not i/2)))
(lo (core:- 1 i0)))
(core:+ hi lo))))
(error "illegal argument to bitwise-not" i)))
(define (bit-count i)
(if (and (core:exact? i)
(core:integer? i))
(cond ((core:= i -1)
0)
((core:= i 0)
0)
(else
(let* ((i0 (if (core:odd? i) 1 0))
(i1 (core:- i i0))
(i/2 (core:quotient i1 2))
(hi (bit-count i/2))
(lo (if (core:> i 0) i0 (core:- 1 i0))))
(core:+ hi lo))))
(error "illegal argument to bit-count" i)))
)
| false |
23b7dd1418a1feb5eded5a9b84115fb9a752a1ba
|
99ea786a1d4553b7ee264843877aaee11eb37115
|
/7-10/3.scm
|
be26342963b92545a87f3ae5f3bfd6c639e75ab2
|
[] |
no_license
|
tyage/pl
|
ef4f62d729aed1222367dcae0f9a547e5d528b06
|
c707b9f5055c12f6aadda60fe89f9c3423e820b6
|
refs/heads/master
| 2016-09-06T05:24:56.565550 | 2013-07-23T22:25:19 | 2013-07-23T22:25:19 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 324 |
scm
|
3.scm
|
(add-load-path ".")
(load "throw-catch")
(define (change coins amount)
(cond ((zero? amount) '())
((null? coins) (throw Fail #f))
(else
(let ((c (car coins)))
(if (> c amount) (change (cdr coins) amount)
(or (catch Fail
(cons c (change coins (- amount c))))
(change (cdr coins) amount) ))))))
| false |
36d52544dfb97e68abad7c868f7bda370f350414
|
2bcf33718a53f5a938fd82bd0d484a423ff308d3
|
/programming/sicp/ch3/ex-3.75.scm
|
2e41e1b38b38627e9923c200cc843e0c3fe45a83
|
[] |
no_license
|
prurph/teach-yourself-cs
|
50e598a0c781d79ff294434db0430f7f2c12ff53
|
4ce98ebab5a905ea1808b8785949ecb52eee0736
|
refs/heads/main
| 2023-08-30T06:28:22.247659 | 2021-10-17T18:27:26 | 2021-10-17T18:27:26 | 345,412,092 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,001 |
scm
|
ex-3.75.scm
|
#lang sicp
(#%require "stream.scm")
;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-24.html#%_thm_3.74
(define (sign-change-detector v1 v2)
(cond ((and (> v1 0) (< v2 0)) -1)
((and (< v1 0) (> v2 0)) 1)
(else 0)))
(define sense-data (list->stream (list 1 2 1.5 1 0.5 -0.1 -2 -3 -2 -0.5 0.2 3 4)))
;; The original version is incorrect because it detects changes between the
;; average and the prior value, not the last two averages.
(define (make-zero-crossings input-stream last-value last-avg)
(let ((avpt (/ (+ (stream-car input-stream)
last-value)
2)))
(cons-stream (sign-change-detector avpt last-avg)
(make-zero-crossings (stream-cdr input-stream)
(stream-car input-stream)
avpt))))
(define zero-crossings (make-zero-crossings sense-data 0 0))
(display-stream zero-crossings)
| false |
afbc10f148d493fc85d4cb5ec9c413104c5e47d2
|
b8b741752da8980afc0d5a15faccb1376afe44de
|
/src/sb-info.scm
|
e9e311bb56d830841c1c294f820b415437f0b08c
|
[] |
no_license
|
dlhawkins94/bob2
|
3ef109e0d563db908acbac5c154774e0b1e2b53e
|
5ac173836d163c863c567a934c831258b748b797
|
refs/heads/master
| 2022-05-04T17:56:47.034947 | 2022-03-31T04:34:48 | 2022-03-31T04:34:48 | 233,669,239 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,630 |
scm
|
sb-info.scm
|
(declare (unit sb-info))
(declare (uses slackbuilds))
(declare (uses util))
(import (chicken format)
(chicken io)
(chicken sort))
(import srfi-1 srfi-13 srfi-69)
(import http-client)
;; For some reason there is a long pause after this finishes printing.
;; Maybe it's the EOF detection?
(define (print-slack-desc sb)
(let ((marker (string-append (sb-name sb) ":")))
(with-input-from-request
(cat-str +repo-url+ "/" (sb-location sb) "/slack-desc")
#f
(lambda ()
(let loop ((line (read-line)))
(unless (eof-object? line)
(when (and (<= (string-length marker)
(string-length line))
(string= marker (string-take line (string-length marker))))
(print (string-drop line (string-length marker))))
(loop (read-line))))))))
(define (search-sbs #!rest terms)
(sort
(apply lset-intersection
(cons (lambda (sb1 sb2)
(equal? (sb-name sb1) (sb-name sb2)))
(map (lambda (term)
(filter identity
(hash-table-map *sblist*
(lambda (name sb)
(and (string-contains name term) sb)))))
terms)))
(lambda (sb1 sb2)
(string<= (sb-name sb1) (sb-name sb2)))))
;; Find all packages which depend on sb-dep
;; To deal with the circular dep problem, we use visited to keep
;; track of which packages we've already checked
(define (find-dependents sb-dep #!optional (g (make-hash-table)) (visited '()))
(let ((visited (cons (sb-name sb-dep) visited)))
(hash-table-for-each *sblist*
(lambda (name sb)
(when (member (sb-name sb-dep) (sb-requires sb))
(unless (member name visited)
(find-dependents sb g visited))
(hash-table-update!/default
g name
(lambda (edges)
(lset-union equal? (list (sb-name sb-dep)) edges))
'()))))
g))
;; Find all packages which sb depends on
(define (find-dependencies sb #!optional (g (make-hash-table)) (visited '()))
(let ((visited (cons (sb-name sb) visited)))
(for-each (lambda (name)
(when (and (not (member name visited))
(hash-table-exists? *sblist* name))
(find-dependencies (hash-table-ref *sblist* name) g visited))
(hash-table-update!/default
g (sb-name sb)
(lambda (edges)
(lset-union equal? (list name) edges))
'()))
(sb-requires sb))
g))
;; Find entire dependency tree for this sb: all packages that eventually require
;; it, and all packages that it needs.
;; the output is a directed graph as a hash table of sb-name : adjacency list
(define (full-dependency-graph sb)
(let ((g (make-hash-table)))
(find-dependents sb g)
(find-dependencies sb g)))
(define (graphviz-sanitize name)
(list->string
(let loop ((chs (string->list name)))
(cond [(null? chs) '()]
[(eq? #\% (car chs))
(append '(#\~ #\%)
(loop (cdr chs)))]
[else (cons (car chs)
(loop (cdr chs)))]))))
(define *digraph-node-attrs*
`((shape . "box")
(style . "filled")
(fillcolor . "#009999")
(fontcolor . "#ffffff")
(ranksep . "20 equally")
(nodesep . "0")))
(define (print-digraph-attrs attrs)
(format #t " [")
(let loop ((attrs attrs))
(format #t "\"~a\" = \"~a\"" (caar attrs) (cdar attrs))
(unless (null? (cdr attrs))
(format #t ", ")
(loop (cdr attrs))))
(format #t "]"))
(define (print-digraph-node name #!optional attrs)
(format #t " \"~a\"" name)
(when attrs (print-digraph-attrs attrs))
(format #t ";~%"))
(define (print-dependency-graph g)
(format #t "digraph dependencies {~%")
(format #t " node ")
(print-digraph-attrs (*digraph-node-attrs*))
(format #t ";~%")
(let ((visited (make-parameter '())))
(hash-table-for-each
g (lambda (name adj-list)
(let ((name-gv (graphviz-sanitize name))
(sb (hash-table-ref/default *sblist* name #f)))
(unless (member name (visited))
(visited (cons name (visited)))
(print-digraph-node name-gv
(cond [(not sb)
'((fillcolor . "#999900"))]
[(not (pkg-installed? name))
'((fillcolor . "#990000"))]
[else #f])))
(for-each (lambda (adj)
(let ((adj-gv (graphviz-sanitize adj))
(sb (hash-table-ref/default *sblist* adj #f)))
(unless (member adj (visited))
(visited (cons adj (visited)))
(print-digraph-node adj-gv
(cond [(not sb)
'((fillcolor . "#999900"))]
[(not (pkg-installed? adj))
'((fillcolor . "#990000"))]
[else #f])))
(format #t " \"~a\" -> \"~a\";~%" name-gv adj-gv)))
adj-list)))))
(format #t "}~%"))
| false |
6664552710b8db9d7c7c194dfe4fb92d0f2564f5
|
7666204be35fcbc664e29fd0742a18841a7b601d
|
/code/2.1.4-interval.scm
|
e42c3db5befced26a708ca63a3df8c84c7ec4d56
|
[] |
no_license
|
cosail/sicp
|
b8a78932e40bd1a54415e50312e911d558f893eb
|
3ff79fd94eda81c315a1cee0165cec3c4dbcc43c
|
refs/heads/master
| 2021-01-18T04:47:30.692237 | 2014-01-06T13:32:54 | 2014-01-06T13:32:54 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,446 |
scm
|
2.1.4-interval.scm
|
#lang racket
(provide
make-interval
lower-bound
upper-bound
add-interval
mul-interval
div-interval
sub-interval)
(define (make-interval a b) (cons a b))
;; 2-07
(define (lower-bound x) (car x))
(define (upper-bound x) (cdr x))
(define (add-interval x y)
(make-interval
(+ (lower-bound x) (lower-bound y))
(+ (upper-bound x) (upper-bound y))))
(define (mul-interval x y)
(let* ((lx (lower-bound x))
(ux (upper-bound x))
(ly (lower-bound y))
(uy (upper-bound y))
(p1 (* lx ly))
(p2 (* lx uy))
(p3 (* ux ly))
(p4 (* ux uy)))
(make-interval
(min p1 p2 p3 p4)
(max p1 p2 p3 p4))))
; 2-10
(define (div-interval x y)
(let ((ly (lower-bound y)) (uy (upper-bound y)))
(if (<= (* ly uy) 0)
(error "illegal to divide interval over 0: " y)
(mul-interval
x
(make-interval (/ 1.0 uy) (/ 1.0 ly))))))
; 2-08
(define (sub-interval x y)
(add-interval
x
(make-interval
(- (upper-bound y))
(- (lower-bound y)))))
;; tests
#|
(define itv1 (make-interval 10 15))
(define itv2 (make-interval 4 5))
(define itv3 (make-interval -2 5))
(add-interval itv1 itv2)
(sub-interval itv1 itv2)
(sub-interval itv1 itv3)
(mul-interval itv1 itv2)
(mul-interval itv1 itv3)
(div-interval itv1 itv2)
;|#
| false |
1e7d0c83354a6d39683b0bdfa5bc0aa55342954d
|
acc632afe0d8d8b94b781beb1442bbf3b1488d22
|
/deps/sdl2/lib/sdl2-internals/helpers/guards.scm
|
faef9cf1cf31d07c215622e907e69c736b45d7e8
|
[
"BSD-2-Clause",
"BSD-3-Clause"
] |
permissive
|
kdltr/life-is-so-pretty
|
6cc6e6c6e590dda30c40fdbfd42a5a3a23644794
|
5edccf86702a543d78f8c7e0f6ae544a1b9870cd
|
refs/heads/master
| 2021-01-20T21:12:00.963219 | 2016-05-13T12:19:02 | 2016-05-13T12:19:02 | 61,128,206 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 3,367 |
scm
|
guards.scm
|
;;
;; chicken-sdl2: CHICKEN Scheme bindings to Simple DirectMedia Layer 2
;;
;; Copyright © 2013, 2015-2016 John Croisant.
;; All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;;
;; - Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; - Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in
;; the documentation and/or other materials provided with the
;; distribution.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
;; FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
;; COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
;; INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
;; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
;; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
;; STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
;; OF THE POSSIBILITY OF SUCH DAMAGE.
(export int-guard
Uint-guard Uint8-guard Uint16-guard Uint32-guard Uint64-guard
Sint-guard Sint8-guard Sint16-guard Sint32-guard Sint64-guard)
(define (int-guard description #!key min max)
(cond
((and min max)
(lambda (value)
(assert (and (integer? value) (<= min value max))
(format "~A must be an integer in range [~S, ~S], but got: ~S"
description min max value))
(inexact->exact value)))
(min
(lambda (value)
(assert (and (integer? value) (<= min value))
(format "~A must be an integer >= ~S, but got: ~S"
description min value))
(inexact->exact value)))
(max
(lambda (value)
(assert (and (integer? value) (<= value max))
(format "~A must be an integer <= ~S, but got: ~S"
description max value))
(inexact->exact value)))
(else
(lambda (value)
(assert (integer? value)
(format "~A must be an integer, but got: ~S"
description value))
(inexact->exact value)))))
(define (Uint-guard description bits)
(int-guard description
min: 0
max: (- (expt 2 bits) 1)))
(define (Uint8-guard description) (Uint-guard description 8))
(define (Uint16-guard description) (Uint-guard description 16))
(define (Uint32-guard description) (Uint-guard description 32))
(define (Uint64-guard description) (Uint-guard description 64))
(define (Sint-guard description bits)
(int-guard description
min: (- (expt 2 (- bits 1)))
max: (- (expt 2 (- bits 1)) 1)))
(define (Sint8-guard description) (Sint-guard description 8))
(define (Sint16-guard description) (Sint-guard description 16))
(define (Sint32-guard description) (Sint-guard description 32))
(define (Sint64-guard description) (Sint-guard description 64))
| false |
0d7bb4ce4b2dd1ecc6033854fc7669f6670fe3c9
|
6a813a177e01e438812eda95577176410ad6bf6b
|
/serialize.scm
|
cea52673765eb67d745c5aca9114d57c24b5bdce
|
[] |
no_license
|
mpacula/Scheme-Power-Tools
|
c3b38c03f2b4a07bccddf2ac1d8b98dfe5c9f630
|
e2d27fb03d9aa4f47173bd5abcc83fa27c7cb3ee
|
refs/heads/master
| 2016-09-10T10:31:31.131658 | 2011-02-23T23:37:09 | 2011-02-23T23:37:09 | 1,296,148 | 21 | 6 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 4,769 |
scm
|
serialize.scm
|
;; Copyright (c) 2010-2011, Maciej Pacula & contributors
;; All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions are met:
;; * Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;; * Redistributions in binary form must reproduce the above copyright
;; notice, this list of conditions and the following disclaimer in the
;; documentation and/or other materials provided with the distribution.
;; * Names of copyright holders may not be used to endorse or promote products
;; derived from this software without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
;; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
;; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
;; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
;; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
;; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;; @name Serialization
;;; @desc Implements a serialization library. Supports reading and writing the usual Scheme primitives, /
;;; as well as hash tables, pathnames and decoded times.
(declare (usual-integrations))
;; Serializes a Scheme object. For most primitives this is equal to the identity function,
;; but for special objects (e.g. hash tables) it does some extra processing. The output is a
;; human-readable s-expression.
(defgen serialize 1)
;; Deserializes an s-expression. The inverse function of c{serialize}.
(defgen deserialize 1)
;; @ignore
(define tagged-value cadr)
;; @ignore
(define (serialize-pair pair)
(cons (serialize (car pair))
(serialize (cdr pair))))
;; @ignore
(define (deserialize-pair pair)
(cons (deserialize (car pair))
(deserialize (cdr pair))))
;; @ignore
(define (deserialize-list lst)
(map deserialize lst))
(defhandler serialize identity string?)
(defhandler serialize identity symbol?)
(defhandler serialize identity number?)
(defhandler serialize identity char?)
(defhandler serialize identity null?)
(defhandler serialize identity boolean?)
(defhandler serialize (tag 'pathname ->namestring) pathname?)
(defhandler serialize (tag 'decoded-time decoded-time->string) decoded-time?)
(defhandler serialize serialize-pair pair?)
(defhandler serialize (tag 'hash-table (compose serialize hash-table->alist)) hash-table?)
(defhandler deserialize identity string?)
(defhandler deserialize identity symbol?)
(defhandler deserialize identity number?)
(defhandler deserialize identity char?)
(defhandler deserialize identity null?)
(defhandler deserialize identity boolean?)
(defhandler deserialize (compose ->pathname tagged-value) (t? 'pathname))
(defhandler deserialize (compose string->decoded-time tagged-value) (t? 'decoded-time))
(defhandler deserialize (compose alist->hash-table tagged-value) (t? 'hash-table))
(defhandler deserialize deserialize-list list?)
(defhandler deserialize deserialize-pair pair?)
;; Serializes an object to the supplied output port.
(define (serialize-to-port obj port)
(write-line (serialize obj) port))
;; Deserializes an object to the supplied input port.
(define (deserialize-from-port port)
(deserialize (read port)))
;; Serializes an object to a file.
(define (serialize-to-file obj pathname)
(with-output-to-file pathname
(lambda ()
(serialize-to-port obj (current-output-port)))))
;; Deserializes an object from a file.
(define (deserialize-from-file pathname)
(with-input-from-file pathname
(lambda ()
(deserialize-from-port (current-input-port)))))
;; Serializes an object to a string.
;; <pre>
#|
(as-string (list 1 2 3 (make-eq-hash-table)))
;Value 22753: "(1 2 3 (hash-table ()))"
|#
;; </pre>
(define (as-string obj)
(let ((out (call-with-output-string
(curry serialize-to-port obj))))
(string-head out (-1+ (string-length out)))))
;; @ignore
;; prints out a number of strings
(defgen my-to-string 1 as-string)
(defhandler my-to-string identity string?)
;; @ignore
(define (print . objs)
(for-each (compose display my-to-string) objs))
;; @ignore
;; prints out a number of strings followed by a newline
(define (println . objs)
(apply print objs) (newline))
| false |
223066361a9191e522f9c99f31727a91384f7938
|
bdcc255b5af12d070214fb288112c48bf343c7f6
|
/r7b-util/bytevector-buffer.nmosh.sls
|
e2fbb8694591bc97fd847f21c1972752b25f4c4f
|
[] |
no_license
|
xaengceilbiths/chez-lib
|
089af4ab1d7580ed86fc224af137f24d91d81fa4
|
b7c825f18b9ada589ce52bf5b5c7c42ac7009872
|
refs/heads/master
| 2021-08-14T10:36:51.315630 | 2017-11-15T11:43:57 | 2017-11-15T11:43:57 | 109,713,952 | 5 | 1 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 407 |
sls
|
bytevector-buffer.nmosh.sls
|
#!chezscheme
(library (r7b-util bytevector-buffer)
(export
get-output-bytevector
open-output-bytevector
)
(import (rnrs)
(primitives sys-get-bytevector
sys-open-bytevector-output-port))
(define get-output-bytevector sys-get-bytevector)
(define (open-output-bytevector) (sys-open-bytevector-output-port))
)
| false |
6e9cc7f663e20e6b16b355d646fb9c1dcdb60173
|
4bf7cad2c748ebf799555fd3edd69950b26e4919
|
/lisp/base32-crockford.scm
|
559f2aa8f43c57580525c8ad5bd429b01513ab09
|
[] |
no_license
|
rlonstein/misc-code-examples
|
d3451243f3c2c6b9814e078ee663cc362281aa84
|
e83c09610e55da7d8104adb875af108558627356
|
refs/heads/master
| 2021-01-21T21:55:21.485483 | 2019-09-22T22:42:03 | 2019-09-22T22:42:03 | 7,757,880 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 6,604 |
scm
|
base32-crockford.scm
|
;;;
;;; Chicken Scheme implementation of Douglas Crockford's Base32 encoding
;;; (http://www.crockford.com/wrmg/base32.html) translated from my own
;;; earlier implementation in Common Lisp
;;;
;;; Copyright (c) 2010-2011, Ross Lonstein
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a copy
;;; of this software and associated documentation files (the "Software"), to deal
;;; in the Software without restriction, including without limitation the rights
;;; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;;; copies of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included in
;;; all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;;; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;;; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
;;; THE SOFTWARE.
;;;
(define encoding-table '#( #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9
#\A #\B #\C #\D #\E #\F #\G #\H #\J #\K
#\M #\N #\P #\Q #\R #\S #\T #\V #\W #\X
#\Y #\Z #\* #\- #\% #\= #\U ))
(define decoding-table '#( 0 1 2 3 4 5 6 7 8 9 ; numbers 0-9
10 11 12 13 14 15 16 17 ; A-H
1 18 19 1 20 21 0 22 ; I,J,K,L,M,N,O,P
23 24 25 26 ; Q,R,S,T
36 ; U (checksum)
27 28 29 30 31 )) ; V,W,X,Y,Z
;;
;; Assumptions about ASCII ordering of chars here...
;;
(define-constant char-num-base (char->integer #\0))
(define-constant char-alpha-base (char->integer #\A))
(define (numchar->value chr)
;; don't bother with lookup, just calculate value
(if (char-numeric? chr) (- (char->integer chr) char-num-base)
(abort (make-property-condition
'char-not-numeric
'value
chr))))
(define (alphachar->value chr)
(if (char-alphabetic? chr)
(vector-ref decoding-table
(+ 10 (- (char->integer (char-upcase chr)) char-alpha-base)))
(abort (make-property-condition
'char-not-alpha
'value
chr))))
(define (char->value chr)
(cond
((char-numeric? chr) (numchar->value chr))
((char-alphabetic? chr) (alphachar->value chr))
((char=? chr #\*) 32)
((char=? chr #\-) 33)
((char=? chr #\$) 34)
((char=? chr #\=) 35)
(else (abort (make-property-condition
'invalid-char
'value
chr)))))
(define (value->char int)
(vector-ref encoding-table int))
(define (b32c-checksum int)
(modulo int 37))
(define (b32c-checksum-char int)
(value->char (b32c-checksum int)))
(define (b32c-valid-checksum? int checksum)
(= checksum (b32c-checksum int)))
(define (exact-integer? n)
(and (integer? n) (exact? n)))
;;;;
;;;; floor & ceiling functions from MIT Scheme by Taylor R. Campbell
;;;;
(define (ceiling-/- n d)
(let ((n (- 0 n)) (d (- 0 d)))
(let ((q (quotient n d)) (r (remainder n d)))
(if (zero? r)
(values q r)
(values (+ q 1) (- d r))))))
(define (ceiling+/+ n d)
(let ((q (quotient n d)) (r (remainder n d)))
(if (zero? r)
(values q r)
(values (+ q 1) (- r d)))))
(define (ceiling/ n d)
(if (and (exact-integer? n) (exact-integer? d))
(cond ((and (negative? n) (negative? d))
(ceiling-/- n d))
((negative? n)
(let ((n (- 0 n)))
(values (- 0 (quotient n d)) (- 0 (remainder n d)))))
((negative? d)
(let ((d (- 0 d)))
(values (- 0 (quotient n d)) (remainder n d))))
(else
(ceiling+/+ n d)))
(let ((q (ceiling (/ n d))))
(values q (- n (* d q))))))
(define (floor-/+ n d)
(let ((n (- 0 n)))
(let ((q (quotient n d)) (r (remainder n d)))
(if (zero? r)
(values (- 0 q) r)
(values (- (- 0 q) 1) (- d r))))))
(define (floor+/- n d)
(let ((d (- 0 d)))
(let ((q (quotient n d)) (r (remainder n d)))
(if (zero? r)
(values (- 0 q) r)
(values (- (- 0 q) 1) (- r d))))))
(define (floor/ n d)
(if (and (exact-integer? n) (exact-integer? d))
(cond ((and (negative? n) (negative? d))
(let ((n (- 0 n)) (d (- 0 d)))
(values (quotient n d) (- 0 (remainder n d)))))
((negative? n) (floor-/+ n d))
((negative? d) (floor+/- n d))
(else (values (quotient n d) (remainder n d))))
(let ((q (floor (/ n d))))
(values q (- n (* d q))))))
;;;;
(define (logn n base)
(/ (log n) (log base)))
(define (integer-length int)
(ceiling (logn (if (negative? int)
(- int)
(+ 1 int))
2)))
(define (b32-encoded-length int)
(let-values (((q r) (ceiling/ (integer-length int) 5)))
(+ (if (zero? q) 1 q) (if (positive? r) 1 0))))
(define (b32c-encode int #!key checksum)
(let loop ((n int)
(acc '()))
(if (zero? n) (list->string (if checksum
(append acc (list (b32c-checksum-char int)))
acc))
(let-values (((q r) (floor/ n 32)))
(loop q (cons (value->char (if (zero? q) n r)) acc))))))
(define (normalize-b32-string str)
(string-delete (char-set #\- #\space) str))
(define (b32c-decode str #!key checksum)
(let ((normalized-str (normalize-b32-string str))
(checkchar #f))
(when checksum
(let ((len (string-length str)))
(set! checkchar (string-ref str (sub1 len)))
(set! str (substring str 0 (sub1 len)))))
(let loop ((c (reverse (string->list str)))
(offset 1)
(sum 0))
(values (if (null? c) sum
(loop (cdr c)
(* 32 offset)
(+ sum (* (char->value (car c)) offset))))
(if checksum (char->value checkchar))))))
| false |
d59d2976de4f7e4b8fc22a0c4e01968555d70e4c
|
7301b8e6fbd4ac510d5e8cb1a3dfe5be61762107
|
/ex-2.78.scm
|
2c9c898d589589f89737bb65655910d91608a01f
|
[] |
no_license
|
jiakai0419/sicp-1
|
75ec0c6c8fe39038d6f2f3c4c6dd647a39be6216
|
974391622443c07259ea13ec0c19b80ac04b2760
|
refs/heads/master
| 2021-01-12T02:48:12.327718 | 2017-01-11T12:54:38 | 2017-01-11T12:54:38 | 78,108,302 | 0 | 0 | null | 2017-01-05T11:44:44 | 2017-01-05T11:44:44 | null |
UTF-8
|
Scheme
| false | false | 1,374 |
scm
|
ex-2.78.scm
|
;;; Exercise 2.78. The internal procedures in the scheme-number package are
;;; essentially nothing more than calls to the primitive procedures +, -, etc.
;;; It was not possible to use the primitives of the language directly because
;;; our type-tag system requires that each data object have a type attached to
;;; it. In fact, however, all Lisp implementations do have a type system, which
;;; they use internally. Primitive predicates such as symbol? and number?
;;; determine whether data objects have particular types. Modify the
;;; definitions of type-tag, contents, and attach-tag from section 2.4.2 so
;;; that our generic system takes advantage of Scheme's internal type system.
;;; That is to say, the system should work as before except that ordinary
;;; numbers should be represented simply as Scheme numbers rather than as pairs
;;; whose car is the symbol scheme-number.
(define (attach-tag type-tag contents)
(cond
[(eq? type-tag 'scheme-number)
contents]
[else
(cons type-tag contents)])
(define (type-tag datum)
(cond
[(number? datum)
'scheme-number]
[(pair? datum)
(car datum)]
[else
(error "Bad tagged datum -- TYPE-TAG" datum)]))
(define (contents datum)
(cond
[(number? datum)
datum]
[(pair? datum)
(cdr datum)]
[else
(error "Bad tagged datum -- CONTENTS" datum)]))
| false |
af0f4ecc54a536ae341404ba7cfcdd75761f612d
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine/unity-engine/runtime-initialize-on-load-method-attribute.sls
|
6877b6d0a05353fb28186bf6a9539cde181f431c
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 578 |
sls
|
runtime-initialize-on-load-method-attribute.sls
|
(library (unity-engine runtime-initialize-on-load-method-attribute)
(export new is? runtime-initialize-on-load-method-attribute?)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
UnityEngine.RuntimeInitializeOnLoadMethodAttribute
a
...)))))
(define (is? a)
(clr-is UnityEngine.RuntimeInitializeOnLoadMethodAttribute a))
(define (runtime-initialize-on-load-method-attribute? a)
(clr-is UnityEngine.RuntimeInitializeOnLoadMethodAttribute a)))
| true |
fff5b9d5bb0d36262ca0b639f9b261e6b6fddb13
|
fb9a1b8f80516373ac709e2328dd50621b18aa1a
|
/ch2/exercise2-80.scm
|
4e6e6a98983084ac45995a6b9022e8828048be2c
|
[] |
no_license
|
da1/sicp
|
a7eacd10d25e5a1a034c57247755d531335ff8c7
|
0c408ace7af48ef3256330c8965a2b23ba948007
|
refs/heads/master
| 2021-01-20T11:57:47.202301 | 2014-02-16T08:57:55 | 2014-02-16T08:57:55 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 514 |
scm
|
exercise2-80.scm
|
;; 問題2.80
; 引数がゼロかどうかテストする汎用演算 =zero? を定義して，汎用算術演算パッケージに設定せよ
; この演算は通常の数，有理数及び複素数に対して働こうとするものとする
(load "./ch2/2-5_system_with_generic_operations.scm")
(define n1 (make-scheme-number 0))
(zero? n1)
(define ra1 (make-rational 0 1))
(zero? ra1)
(define ri1 (make-complex-from-real-imag 0 0))
(zero? ri1)
(define ma1 (make-complex-from-mag-ang 0 0))
(zero? ma1)
| false |
b110b41cd455fa50b4c0f928c2482139533c3ce7
|
958488bc7f3c2044206e0358e56d7690b6ae696c
|
/scheme/macro/syntax-error.scm
|
2616a6dd07ac886f76424d8f1d0859e8ae55c9eb
|
[] |
no_license
|
possientis/Prog
|
a08eec1c1b121c2fd6c70a8ae89e2fbef952adb4
|
d4b3debc37610a88e0dac3ac5914903604fd1d1f
|
refs/heads/master
| 2023-08-17T09:15:17.723600 | 2023-08-11T12:32:59 | 2023-08-11T12:32:59 | 40,361,602 | 3 | 0 | null | 2023-03-27T05:53:58 | 2015-08-07T13:24:19 |
Coq
|
UTF-8
|
Scheme
| false | false | 130 |
scm
|
syntax-error.scm
|
(require 'macro)
(define-syntax syntax-error
(syntax-rules ()
((syntax-error) (syntax-error "Bad use of syntax error!"))))
| true |
a7e12394590c25185da92406ee3efc59653bec41
|
8a0660bd8d588f94aa429050bb8d32c9cd4290d5
|
/sitelib/sagittarius/vm/profiler.scm
|
f8d0601edb767e854f9b85b19780a1609f4351a9
|
[
"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
|
Scheme
| false | false | 2,978 |
scm
|
profiler.scm
|
;; -*- scheme -*-
(library (sagittarius vm profiler)
(export profiler-start
profiler-stop
profiler-show
profiler-get-result
profiling)
(import (core)
(core base)
(sagittarius))
(define-syntax profiling
(er-macro-transformer
(lambda (form rename compare)
(or (= (length form) 2)
(assertion-violation 'profiler-show
(format "wrong number of arguments, required 2, but got ~a"
(length form))
form))
`(,(rename 'dynamic-wind)
,(rename 'profiler-start)
(,(rename 'lambda) () ,(cadr form))
,(rename 'profiler-stop)))))
(define (profiler-get-result)
(cond ((profiler-raw-result)
=> (lambda (result)
(hashtable-map (lambda (k v)
(cons k v))
result)))
(else #f)))
(define (profiler-show results sort-by max-rows)
(if (not results)
(cond ((profiler-get-result)
=> (lambda (result)
(show-stats result sort-by max-rows)))
(else
(print "No profiling data has been gathered.")))
(print "No profiling data has been gathered.")))
(define (show-stats stat sort-by max-rows)
(let* ((num-samples (fold (lambda (entry cnt) (+ (cddr entry) cnt)) 0 stat))
(sum-time (* num-samples 0.01))
(sorter (case sort-by
[(time)
(lambda (a b)
(or (> (cddr a) (cddr b))
(and (= (cddr a) (cddr b))
(> (cadr a) (cadr b)))))]
[(count)
(lambda (a b)
(or (> (cadr a) (cadr b))
(and (= (cadr a) (cadr b))
(> (cddr a) (cddr b)))))]
[(time-per-call)
(lambda (a b)
(> (/ (cddr a) (cadr a)) (/ (cddr b) (cadr b))))]
[else
(error 'profiler-show
"sort-by argument must be either one of time, count, or time-per-call, but got:" sort-by)]))
(sorted (list-sort sorter stat)))
(print "Profiler statistics (total "num-samples" samples, "
sum-time " seconds)")
(print " num time/ total")
(print "Name calls call(ms) samples")
(print "--------------------------------------------------+-------+--------+-----------")
(for-each
(lambda (e)
(let* ((name (car e))
(ncalls (cadr e))
(samples (cddr e))
)
(format #t "~50a ~7a ~8a ~5a(~3a%)\n"
name ncalls (time/call samples ncalls) samples
(if (zero? num-samples)
0
(exact (round (* 100 (/ samples num-samples))))))))
(if (integer? max-rows)
(if (> (length sorted) max-rows)
(take sorted max-rows)
sorted)
sorted)))
)
(define (time/call samples ncalls)
(* samples 10))
#;(define (time/call samples ncalls)
(let ((time (* 10.0 (/ samples ncalls)))) ;; in ms
(receive (frac int) (modf (* time 10000))
(let ((val (inexact->exact (if (>= frac 0.5) (+ int 1) int))))
(let ((q (quotient val 10000))
(r (remainder val 10000)))
(format "~2d.~4,'0d" q r))))))
)
| true |
d12446c908a26fd2d56619dc9ba50c3761f8d5f9
|
defeada37d39bca09ef76f66f38683754c0a6aa0
|
/UnityEngine.Networking/unity-engine/networking/network-system/animation-trigger-message.sls
|
d33cd9e3b7d1a8607f1159151a23970b0aa2cf47
|
[] |
no_license
|
futsuki/ironscheme-port
|
2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5
|
4e7a81b0fbeac9a47440464988e53fb118286c54
|
refs/heads/master
| 2016-09-06T17:13:11.462593 | 2015-09-26T18:20:40 | 2015-09-26T18:20:40 | 42,757,369 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,535 |
sls
|
animation-trigger-message.sls
|
(library (unity-engine
networking
network-system
animation-trigger-message)
(export new
is?
animation-trigger-message?
deserialize
serialize
net-id-get
net-id-set!
net-id-update!
hash-get
hash-set!
hash-update!)
(import (ironscheme-clr-port))
(define-syntax new
(lambda (e)
(syntax-case e ()
((_ a ...)
#'(clr-new
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
a
...)))))
(define (is? a)
(clr-is
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
a))
(define (animation-trigger-message? a)
(clr-is
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
a))
(define-method-port
deserialize
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
Deserialize
(System.Void UnityEngine.Networking.NetworkReader))
(define-method-port
serialize
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
Serialize
(System.Void UnityEngine.Networking.NetworkWriter))
(define-field-port
net-id-get
net-id-set!
net-id-update!
()
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
netId
UnityEngine.Networking.NetworkInstanceId)
(define-field-port
hash-get
hash-set!
hash-update!
()
UnityEngine.Networking.NetworkSystem.AnimationTriggerMessage
hash
System.Int32))
| true |
c5041eeac87eec68de9e2d040d53bb7d96f68674
|
c74dcb1facbd920d762017345171f47f8e41d0c5
|
/chapter_3/3.2.scm
|
c3e46d72814e1178ca428afb6f5c72c007466205
|
[] |
no_license
|
akash-akya/sicp-exercises
|
5125c1118c7f0e4400cb823508797fb67c745592
|
c28f73719740c2c495b7bc38ee8b790219482b67
|
refs/heads/master
| 2021-06-15T19:12:47.679967 | 2019-08-03T14:03:20 | 2019-08-03T14:03:20 | 136,158,517 | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 1,531 |
scm
|
3.2.scm
|
#lang sicp
(#%require "utils.scm")
;; Exercise 3.2: In software-testing applications, it is useful to be
;; able to count the number of times a given procedure is called
;; during the course of a computation. Write a procedure
;; make-monitored that takes as input a procedure, f, that itself
;; takes one input. The result returned by make-monitored is a third
;; procedure, say mf, that keeps track of the number of times it has
;; been called by maintaining an internal counter. If the input to mf
;; is the special symbol how-many-calls?, then mf returns the value of
;; the counter. If the input is the special symbol reset-count, then
;; mf resets the counter to zero. For any other input, mf returns the
;; result of calling f on that input and increments the counter. For
;; instance, we could make a monitored version of the sqrt procedure:
;; (define s (make-monitored sqrt))
;; (s 100)
;; 10
;; (s 'how-many-calls?)
;; 1
(define (make-monitored f)
(let ((counter 0))
(define (moniter a)
(set! counter (inc counter))
(f a))
(define (dispatch arg)
(cond ((eq? arg 'how-many-calls?)
counter)
((eq? arg 'reset-count)
(set! counter 0))
(else
(moniter arg))))
dispatch))
;; test
(define s (make-monitored sqrt))
(test-equal (s 100) 10)
(test-equal (s 'how-many-calls?) 1)
(s 'reset-count)
(test-equal (s 'how-many-calls?) 0)
(test-equal (s 400) 20)
(test-equal (s 25) 5)
(test-equal (s 'how-many-calls?) 2)
| false |
7df85f32a1a15ad9928e0ad959a375baba72046a
|
86092887e6e28ebc92875339a38271319a87ea0d
|
/Ch3/3_30.scm
|
c83c22494bcddf4e28c0f47e96ae7d89c08584df
|
[] |
no_license
|
a2lin/sicp
|
5637a172ae15cd1f27ffcfba79d460329ec52730
|
eeb8df9188f2a32f49695074a81a2c684fe6e0a1
|
refs/heads/master
| 2021-01-16T23:55:38.885463 | 2016-12-25T07:52:07 | 2016-12-25T07:52:07 | 57,107,602 | 1 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 646 |
scm
|
3_30.scm
|
(define (ripple-carry-adder n ak bk sk c)
(if (null? ak)
'ok
((full-adder (car ak) (car bk) c sk c)
(ripple-carry-adder (n-1) (cdr ak) (cdr bk) (cdr sk) c))))
; we know from previous that OR = AND + 2NEG
; FA's CARRY bit (the max determinator of the ripple carry adder) =
; one HA SUM + one HA CARRY + one OR delay.
; HA SUM is the greater of 2AND + NEG or OR + AND
; since OR + NEG = AND + 2NEG, we have 2AND + 2NEG vs 2AND + NEG, and 2AND + 2NEG is larger.
; HA CARRY is one AND delay.
; therefore the minimum delay to Carry is AND + 2AND + 2NEG + OR;
; or 3AND + 2 NEG + AND + 2NEG
; or 4AND + 4NEG.
; so it's 4n AND + 4n NEG?
| false |
55bd7a45f72480bc288fc7d3a8927bf5454dddd3
|
1dcae2ac82bd47eac29d8f938ec51c9b724bede0
|
/examples/basic.scm
|
da962c69d90fc288e2c18c85677491d01b334f32
|
[
"BSD-3-Clause"
] |
permissive
|
stjordanis/bsdscheme
|
9730afab326c818daaea4ad96886ca0826320297
|
ffdc0ab5e8a2cadabcc1ca394ae06072972b75de
|
refs/heads/master
| 2021-09-21T23:30:57.615938 | 2018-09-03T02:48:41 | 2018-09-03T02:48:41 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Scheme
| false | false | 22 |
scm
|
basic.scm
|
(display 1)
(newline)
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.