performance measurements

Each table row shows performance measurements for this Lisp SBCL program with a particular command-line input value N.

 N  CPU secs Elapsed secs Memory KB Code B ≈ CPU Load
250,000Bad Output  2005   

Read the ↓ make, command line, and program output logs to see how this program was run.

Read fasta-redux benchmark to see what this program should do.

 notes

This is SBCL 1.2.0, an implementation of ANSI Common Lisp.

 fasta-redux Lisp SBCL #4 program source code

;;   The Computer Language Benchmarks Game

;;   http://benchmarksgame.alioth.debian.org/

;;;

;;; By Jon Smith (rev 1)

;;; Fixed a bug in my use of write-sequence, which wasn't apparent on 

;;; my machine, for whatever reason.

;;; Based off of java implementation. 

;;;

;;; To compile

;;; sbcl --load fastab.lisp --eval "(save-lisp-and-die \"fastab.core\" :purify t :toplevel (lambda () (main) (quit)))"

;;; To run

;;; sbcl --noinform --core fastab.core %A

;(setf *efficiency-note-cost-threshold* 1)


(declaim (optimize (speed 3) (safety 0) (debug 0)))

(defconstant line-length 60)
(defconstant out-buffer-size (* 256 1024))
(defconstant lookup-size (* 4 1024))
(defconstant lookup-scale (the double-float (* 1.0d0 (- lookup-size 1))))
(defconstant lim (- out-buffer-size (* 2 line-length) 1))

(eval-when (:load-toplevel :compile-toplevel :execute)

  (defstruct freq 
    (c #\z :type character)
    (m 0.0d0 :type double-float))

  (defmacro frequify (&rest freq-pairs)
    `(frequify-fn ',(mapcar (lambda (s)
			      (destructuring-bind (b f) s
				(list b f)))
			    freq-pairs)))

  (defun frequify-fn (parsed-freq-pairs)
    (declare (type list parsed-freq-pairs))
    (let ((i 0)
	  (array (make-array (length parsed-freq-pairs))))
      (dolist (pair parsed-freq-pairs)
	(destructuring-bind (byte double) pair
	  (let ((fr (make-freq :c byte :m double)))
	    (setf (aref array i) fr)))
	(incf i))
      array))

  (defun sum-and-scale (a)
    (declare (type (simple-array freq (*)) a)) 
    (let ((p 0.0d0))
      (loop for i from 0 below (length a)
	 do (setf (freq-m (aref a i))
		  (* (incf p (freq-m (aref a i))) lookup-scale)))
      (setf (freq-m (aref a (- (length a) 1))) lookup-scale))
    a)
  
#+x86(defmacro ub (a)
       `(the (unsigned-byte 32) ,a))

(defmacro fx (a)
    `(the fixnum ,a))
  
  (defsetf out-ct set-out-ct))

(declaim (inline random-next))

(defparameter *last* 42)
#+x86-64(declaim (type (unsigned-byte 60) *last*))

#+x86(declaim (type (unsigned-byte 29) *last*))

(defconstant IM 139968)
(defconstant IA 3877)
(defconstant IC 29573)
(defconstant scale (/ lookup-scale IM))

(defconstant im-minus-1500 (- IM 1500))

#+x86-64(defun random-next ()
	  (declare (values (unsigned-byte 64)))
	  (let ((last *last*))
	    (setf *last* (the (integer 0 138467) (mod (+ (fx (* last IA)) IC) IM)))))

#+x86(defun random-next ()
       (declare (values (unsigned-byte 32)))
       ;;fixnums are nice, but being able to use them is a pain in the ass

       (let ((last *last*))
	     (setf *last* (mod (ub (+ (ub (* last IA)) IC)) IM))
))



(let ((out-buf (make-array out-buffer-size :element-type 'character))
      (ct 0))
  (declare (type (simple-array character (*)) out-buf)
	   (type fixnum ct))

  (let ((stream *standard-output*))
    (defun out-check-flush ()
      (when (>= ct lim)
	(write-sequence out-buf stream :start 0 :end ct) (setf ct 0)))

    (defun out-close ()
      (write-sequence out-buf stream :start 0 :end ct)
      (setf ct 0)))

  (let ((lookup (make-array lookup-size
			    :element-type 'freq
			    :initial-element (make-freq))))
    (declare (type (simple-array freq (*)) lookup))

    (defun random-fasta-make-lookup (a)
      (declare (type (simple-array freq (*)) a))
      (let ((j 0))
	(loop for i from 0 below lookup-size
	      do (loop while (< (freq-m (aref a j)) (* 1.0d0 i))  do (incf j))
	      do (setf (aref lookup i) (aref a j)))))

    (defun random-fasta-add-line (bytes)
      (declare (type fixnum bytes))
      (out-check-flush)
      (let ((lct ct))
	(declare (type fixnum lct))
	(loop while (< lct (fx (+ ct bytes)))
	      do (let* ((r (* (random-next) scale))
			(ai (truncate r)))
		   (loop while (< (freq-m (aref lookup ai)) r)
			 do (incf ai))
		   (setf (aref out-buf lct) (freq-c (aref lookup ai)))
		   (incf lct)))

	(setf (aref out-buf lct) #\NEWLINE)
	(incf lct)
	(setf ct lct)
	(values))))

  (defun random-fasta-make (desc a n)
    (declare (type (simple-array character (*)) desc)
	     (type fixnum n))

    (random-fasta-make-lookup a)

    (let ((len (length desc)))
      (replace out-buf desc :start1 ct :start2 0 :end1 (fx (incf ct len)) :end2 len))

    (setf (aref out-buf ct) #\NEWLINE)
    (incf ct)
    (loop while (> n 0)
	  do (let ((bytes (min line-length n)))
	       (random-fasta-add-line bytes)
	       (decf n bytes)))
    (values))

  (defun repeat-fasta-make (desc alu n)
    (declare (type (simple-array character (*)) desc alu)
	     (type fixnum n))
    (replace out-buf desc :start1 ct :end2 (length desc))
    (incf ct (length desc))
    (setf (aref out-buf ct) #\NEWLINE)
    (incf ct)
    (let ((buf (make-array (+ (length alu) line-length))))
      (loop for i of-type fixnum from 0 below (length buf) by (length alu)
	    do (replace buf alu :start1 i :end2 (min (length alu) (- (length buf) 1))))
      (let ((pos 0))
	(loop while (> n 0)
	      do (let ((bytes (min line-length n)))
		   (out-check-flush)
		   (replace out-buf buf :start2 pos :start1 ct :end2 (the fixnum (+ pos bytes)))
		   (incf ct bytes)
		   (setf (aref out-buf ct) #\NEWLINE)
		   (incf ct)
		   (setf pos (mod (the fixnum (+ pos bytes)) (length alu)))
		   (decf n bytes)))))
    (values)))


  (let ((ALU (concatenate 'string 
			  "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"
			  "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"
			  "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"
			  "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"
			  "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"
			  "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"
			  "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"))
	(IUB (sum-and-scale (frequify 
			     (#\a 0.27d0) (#\c 0.12d0) (#\g 0.12d0) (#\t 0.27d0)
			     (#\B 0.02d0) (#\D 0.02d0) (#\H 0.02d0) (#\K 0.02d0)
			     (#\M 0.02d0) (#\N 0.02d0) (#\R 0.02d0) (#\S 0.02d0)
			     (#\V 0.02d0) (#\W 0.02d0) (#\Y 0.02d0))))
	(homo-sapiens 
	 (sum-and-scale (frequify 
			 (#\a 0.3029549426680d0)
			 (#\c 0.1979883004921d0)
			 (#\g 0.1975473066391d0)
			 (#\t 0.3015094502008d0)))))

    (defun main (&optional in-n)
      (let ((n (or in-n
		   (ignore-errors
		     (parse-integer (car (last #+sbcl sb-ext:*posix-argv*
					       #+cmu  extensions:*command-line-strings*
					       #+gcl  si::*command-args*
					       #+clisp nil)))))))
	(declare (type fixnum n))
	(repeat-fasta-make ">ONE Homo sapiens alu" ALU (the fixnum (* n 2)))
	(random-fasta-make ">TWO IUB ambiguity codes" IUB (the fixnum (* n 3)))
	(random-fasta-make ">THREE Homo sapiens frequency" homo-sapiens (the fixnum (* n 5)))
	(out-close))))

 make, command-line, and program output logs

Sat, 31 May 2014 04:44:42 GMT

MAKE:
cp: ‘fastaredux.sbcl-4.sbcl’ and ‘./fastaredux.sbcl-4.sbcl’ are the same file
SBCL built with: /usr/local/bin/sbcl --userinit /dev/null --batch --eval '(load "fastaredux.sbcl-4.sbcl_compile")'
### START fastaredux.sbcl-4.sbcl_compile
(handler-bind ((sb-ext:defconstant-uneql      (lambda (c) (abort c))))      (load (compile-file "fastaredux.sbcl-4.sbcl" ))) (save-lisp-and-die "sbcl.core" :purify t)
### END fastaredux.sbcl-4.sbcl_compile

; compiling file "/home/dunham/benchmarksgame/bench/fastaredux/fastaredux.sbcl-4.sbcl" (written 24 JAN 2013 02:01:15 PM):
; compiling (DECLAIM (OPTIMIZE # ...))
; compiling (DEFCONSTANT LINE-LENGTH ...)
; compiling (DEFCONSTANT OUT-BUFFER-SIZE ...)
; compiling (DEFCONSTANT LOOKUP-SIZE ...)
; compiling (DEFCONSTANT LOOKUP-SCALE ...)
; compiling (DEFCONSTANT LIM ...)
; compiling (DEFSTRUCT FREQ ...)
; file: /home/dunham/benchmarksgame/bench/fastaredux/fastaredux.sbcl-4.sbcl
; in: DEFSTRUCT FREQ
;     (DEFSTRUCT FREQ (C #\z :TYPE CHARACTER) (M 0.0d0 :TYPE DOUBLE-FLOAT))
; --> PROGN SB-KERNEL::DELAY-DEFSTRUCT-FUNCTIONS PROGN DEFUN PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'FREQ-M
;                    (SB-INT:NAMED-LAMBDA FREQ-M
;                        (SB-KERNEL:INSTANCE)
;                      (BLOCK FREQ-M
;                        (TRULY-THE DOUBLE-FLOAT
;                                   (SB-KERNEL:%RAW-INSTANCE-REF/DOUBLE # 0))))
;                    NIL 'NIL (SB-C:SOURCE-LOCATION))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; ==>
;   (SB-IMPL::%DEFUN '(SETF FREQ-M)
;                    (SB-INT:NAMED-LAMBDA (SETF FREQ-M)
;                        (SB-KERNEL::VALUE SB-KERNEL:INSTANCE)
;                      (BLOCK FREQ-M (SETF # #)))
;                    NIL 'NIL (SB-C:SOURCE-LOCATION))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; compiling (DEFMACRO FREQUIFY ...)
; compiling (DEFUN FREQUIFY-FN ...)
; compiling (DEFUN SUM-AND-SCALE ...)
; compiling (DEFMACRO UB ...)
; compiling (DEFMACRO FX ...)
; compiling (DEFSETF OUT-CT ...)
; compiling (DECLAIM (INLINE RANDOM-NEXT))
; compiling (DEFPARAMETER *LAST* ...)
; compiling (DECLAIM (TYPE # ...))
; compiling (DEFCONSTANT IM ...)
; compiling (DEFCONSTANT IA ...)
; compiling (DEFCONSTANT IC ...)
; compiling (DEFCONSTANT SCALE ...)
; compiling (DEFCONSTANT IM-MINUS-1500 ...)
; compiling (DEFUN RANDOM-NEXT ...)
; compiling (LET (# #) ...)
; compiling (LET (# # ...) ...)
; file: /home/dunham/benchmarksgame/bench/fastaredux/fastaredux.sbcl-4.sbcl
; in:
;      LET ((ALU
;        (CONCATENATE 'STRING "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"
;                     "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"
;                     "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"
;                     "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"
;                     "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"
;                     "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"
;                     "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"))
;       (IUB
;        (SUM-AND-SCALE
;         (FREQUIFY (#\a 0.27d0) (#\c 0.12d0) (#\g 0.12d0) (#\t 0.27d0)
;                   (#\B 0.02d0) (#\D 0.02d0) (#\H 0.02d0) (#\K 0.02d0)
;                   (#\M 0.02d0) (#\N 0.02d0) (#\R 0.02d0) ...)))
;       (HOMO-SAPIENS
;        (SUM-AND-SCALE
;         (FREQUIFY (#\a 0.302954942668d0) (#\c 0.1979883004921d0)
;                   (#\g 0.1975473066391d0) (#\t 0.3015094502008d0)))))
;     (CONCATENATE 'STRING "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"
;                  "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"
;                  "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"
;                  "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"
;                  "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"
;                  "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"
;                  "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA")
; --> APPLY MULTIPLE-VALUE-CALL LAMBDA FUNCTION 
; ==>
;   (LET* ((SB-C::.LENGTH. (+ 42 42 42 42 42 42 35))
;          (SB-C::.POS. 287)
;          (SB-C::.STRING. (MAKE-STRING SB-C::.LENGTH. :ELEMENT-TYPE 'CHARACTER)))
;     (DECLARE (TYPE SB-INT:INDEX SB-C::.LENGTH. SB-C::.POS.)
;              (MUFFLE-CONDITIONS COMPILER-NOTE))
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      ...)
;     (PROGN
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\T)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\C)
;      (SETF (AREF SB-C::.STRING. #) #\G)
;      (SETF (AREF SB-C::.STRING. #) #\A)
;      ...)
;     SB-C::.STRING.)
; 
; caught STYLE-WARNING:
;   The variable SB-C::.POS. is defined but never used.
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition
;   printed 2 notes


; /home/dunham/benchmarksgame_onecore/fastaredux/tmp/fastaredux.sbcl-4.fasl written
; compilation finished in 0:00:00.395
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into sbcl.core:
writing 3528 bytes from the read-only space at 0x0x1000000
writing 2240 bytes from the static space at 0x0x1100000
writing 31322112 bytes from the dynamic space at 0x0x9000000
done]
### START fastaredux.sbcl-4.sbcl_run
(main) (quit)
### END fastaredux.sbcl-4.sbcl_run

1.06s to complete and log all make actions

COMMAND LINE:
/usr/local/bin/sbcl   --noinform --core sbcl.core --userinit /dev/null --load fastaredux.sbcl-4.sbcl_run 250000

UNEXPECTED OUTPUT 

Binary files _out and 250000_out differ

(TRUNCATED) PROGRAM OUTPUT:
>ONE Homo sapiens alu
AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACA
GAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCG
TCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCAC
TCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCT
GGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCG
AGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCA
AAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC




AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCG
ACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACT
CCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAG
CACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AG
CCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGA
GCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTC
TCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTC
C



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGG
GCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAG
ACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAA
AAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC




AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGAC
AGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCC
GTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCA
CTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCC
TGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGC
GAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTC
AAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC




AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGC
GACAGAGCGAGACTCCGTCTCAAAAAGCACTCC



AGCCTGGGCGACAGAGCGAGAC
TCCGTCTCAAAAAGCACTCC



AGCCTG

Revised BSD license

  Home   Conclusions   License   Play