diff options
Diffstat (limited to 'src/pkg/exp')
68 files changed, 953 insertions, 15773 deletions
diff --git a/src/pkg/exp/4s/4s.go b/src/pkg/exp/4s/4s.go deleted file mode 100644 index 271af78e2..000000000 --- a/src/pkg/exp/4s/4s.go +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This is a simple demo of Go running under Native Client. -// It is a tetris clone built on top of the exp/nacl/av and exp/draw -// packages. -// -// See ../nacl/README for how to run it. -package main - -import ( - "exp/nacl/av" - "exp/nacl/srpc" - "log" - "runtime" - "os" -) - -var sndc chan []uint16 - -func main() { - // Native Client requires that some calls are issued - // consistently by the same OS thread. - runtime.LockOSThread() - - if srpc.Enabled() { - go srpc.ServeRuntime() - } - - args := os.Args - p := pieces4 - if len(args) > 1 && args[1] == "-5" { - p = pieces5 - } - dx, dy := 500, 500 - w, err := av.Init(av.SubsystemVideo|av.SubsystemAudio, dx, dy) - if err != nil { - log.Exit(err) - } - - sndc = make(chan []uint16, 10) - go audioServer() - Play(p, w) -} - -func audioServer() { - // Native Client requires that all audio calls - // original from a single OS thread. - runtime.LockOSThread() - - n, err := av.AudioStream(nil) - if err != nil { - log.Exit(err) - } - for { - b := <-sndc - for len(b)*2 >= n { - var a []uint16 - a, b = b[0:n/2], b[n/2:] - n, err = av.AudioStream(a) - if err != nil { - log.Exit(err) - } - println(n, len(b)*2) - } - a := make([]uint16, n/2) - for i := range b { - a[i] = b[i] - } - n, err = av.AudioStream(a) - } -} - -func PlaySound(b []uint16) { sndc <- b } - -var whoosh = []uint16{ -// Insert your favorite sound samples here. -} diff --git a/src/pkg/exp/4s/4s.html b/src/pkg/exp/4s/4s.html deleted file mode 100644 index 924f8b118..000000000 --- a/src/pkg/exp/4s/4s.html +++ /dev/null @@ -1,26 +0,0 @@ - - -<h1>games/4s</h1> -<table><tr><td valign=top> -<embed name="nacl_module" id="pluginobj" src="8.out" type="application/x-nacl-srpc" width=400 height=600> -<td valign=top> -This is a simple block stacking game, a port of Plan 9's -<a href="http://plan9.bell-labs.com/magic/man2html/1/games">games/4s</a> -<br><br> -To play using the keyboard: -as the blocks fall, the <i>a</i>, <i>s</i>, <i>d</i>, and <i>f</i> keys -move the block left, rotate the block left, rotate the block right, -anad move the block right, respectively. -To drop a block, type the space key. -<b>You may need to click on the game window to -focus the keyboard on it.</b> -<br><br> -To play using the mouse: -as the blocks fall, moving the mouse horizontally positions -the block; left or right clicks rotate the block left or right. -A middle click drops the block. -(Unfortunately, some environments seem to intercept -the middle click before it gets to Native Client.) -<br><br> -To pause the game, type <i>z</i>, <i>p</i>, or the escape key. -</table> diff --git a/src/pkg/exp/4s/5s.go b/src/pkg/exp/4s/5s.go deleted file mode 100644 index efeb6f116..000000000 --- a/src/pkg/exp/4s/5s.go +++ /dev/null @@ -1,9 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Hack to produce a binary that defaults to 5s. - -package main - -func init() { pieces4 = pieces5 } diff --git a/src/pkg/exp/4s/5s.html b/src/pkg/exp/4s/5s.html deleted file mode 100644 index 5fa110753..000000000 --- a/src/pkg/exp/4s/5s.html +++ /dev/null @@ -1,26 +0,0 @@ - - -<h1>games/5s</h1> -<table><tr><td valign=top> -<embed name="nacl_module" id="pluginobj" src="8.5s" type="application/x-nacl-srpc" width=400 height=600> -<td valign=top> -This is a simple block stacking game, a port of Plan 9's -<a href="http://plan9.bell-labs.com/magic/man2html/1/games">games/5s</a> -<br><br> -To play using the keyboard: -as the blocks fall, the <i>a</i>, <i>s</i>, <i>d</i>, and <i>f</i> keys -move the block left, rotate the block left, rotate the block right, -anad move the block right, respectively. -To drop a block, type the space key. -<b>You may need to click on the game window to -focus the keyboard on it.</b> -<br><br> -To play using the mouse: -as the blocks fall, moving the mouse horizontally positions -the block; left or right clicks rotate the block left or right. -A middle click drops the block. -(Unfortunately, some environments seem to intercept -the middle click before it gets to Native Client.) -<br><br> -To pause the game, type <i>z</i>, <i>p</i>, or the escape key. -</table> diff --git a/src/pkg/exp/4s/Makefile b/src/pkg/exp/4s/Makefile deleted file mode 100644 index 8ad390591..000000000 --- a/src/pkg/exp/4s/Makefile +++ /dev/null @@ -1,20 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -all: 8.out 8.5s - -4s.8: 4s.go data.go xs.go - 8g 4s.go data.go xs.go - -5s.8: 5s.go 4s.go data.go xs.go - 8g 5s.go 4s.go data.go xs.go - -8.out: 4s.8 - 8l 4s.8 - -8.5s: 5s.8 - 8l -o 8.5s 5s.8 - -clean: - rm -f *.8 8.out diff --git a/src/pkg/exp/4s/data.go b/src/pkg/exp/4s/data.go deleted file mode 100644 index ac30fabf7..000000000 --- a/src/pkg/exp/4s/data.go +++ /dev/null @@ -1,142 +0,0 @@ -// games/4s - a tetris clone -// -// Derived from Plan 9's /sys/src/games/xs.c -// http://plan9.bell-labs.com/sources/plan9/sys/src/games/xs.c -// -// Copyright (C) 2003, Lucent Technologies Inc. and others. All Rights Reserved. -// Portions Copyright 2009 The Go Authors. All Rights Reserved. -// Distributed under the terms of the Lucent Public License Version 1.02 -// See http://plan9.bell-labs.com/plan9/license.html - -package main - -import . "exp/draw" - -var pieces4 = []Piece{ - Piece{0, 0, Point{4, 1}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 0, Point{1, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - Piece{2, 0, Point{4, 1}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 0, Point{1, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 3, Point{2, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{-1, 0}}, nil, nil}, - Piece{1, 3, Point{2, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{-1, 0}}, nil, nil}, - Piece{2, 3, Point{2, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{-1, 0}}, nil, nil}, - Piece{3, 3, Point{2, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{-1, 0}}, nil, nil}, - - Piece{0, 1, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{1, 1, Point{2, 3}, []Point{Point{1, 0}, Point{0, 1}, Point{0, 1}, Point{-1, 0}}, nil, nil}, - Piece{2, 1, Point{3, 2}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 1, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 2, Point{3, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{0, -1}}, nil, nil}, - Piece{1, 2, Point{2, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 2, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - Piece{3, 2, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 4, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{1, 4, Point{2, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 4, Point{3, 2}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 4, Point{2, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{1, -1}}, nil, nil}, - - Piece{0, 5, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{1, 5, Point{2, 3}, []Point{Point{1, 0}, Point{0, 1}, Point{-1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 5, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 5, Point{2, 3}, []Point{Point{1, 0}, Point{0, 1}, Point{-1, 0}, Point{0, 1}}, nil, nil}, - - Piece{0, 6, Point{3, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{1, 0}}, nil, nil}, - Piece{1, 6, Point{2, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 6, Point{3, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{0, -1}, Point{1, 0}}, nil, nil}, - Piece{3, 6, Point{2, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, -} - -var pieces5 = []Piece{ - Piece{0, 1, Point{5, 1}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 1, Point{1, 5}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - Piece{2, 1, Point{5, 1}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 1, Point{1, 5}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 0, Point{4, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{1, 0, Point{2, 4}, []Point{Point{1, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}, Point{-1, 0}}, nil, nil}, - Piece{2, 0, Point{4, 2}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 0, Point{2, 4}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 2, Point{4, 2}, []Point{Point{0, 0}, Point{0, 1}, Point{1, -1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 2, Point{2, 4}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}}, nil, nil}, - Piece{2, 2, Point{4, 2}, []Point{Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{0, -1}}, nil, nil}, - Piece{3, 2, Point{2, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{0, 1}, Point{1, 0}}, nil, nil}, - - Piece{0, 7, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{0, 1}, Point{0, 1}}, nil, nil}, - Piece{1, 7, Point{3, 3}, []Point{Point{0, 2}, Point{1, 0}, Point{1, 0}, Point{0, -1}, Point{0, -1}}, nil, nil}, - Piece{2, 7, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 7, Point{3, 3}, []Point{Point{0, 2}, Point{0, -1}, Point{0, -1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - - Piece{0, 3, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-2, 1}, Point{1, 0}}, nil, nil}, - Piece{1, 3, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 3, Point{3, 2}, []Point{Point{1, 0}, Point{1, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 3, Point{2, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - - Piece{0, 4, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - Piece{1, 4, Point{2, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 4, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 4, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 7, Point{3, 2}, []Point{Point{0, 0}, Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 7, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{-1, 1}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 7, Point{3, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-2, 1}, Point{2, 0}}, nil, nil}, - Piece{3, 7, Point{2, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - - Piece{0, 5, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{1, 5, Point{3, 3}, []Point{Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{2, 5, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 5, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - - Piece{0, 6, Point{3, 3}, []Point{Point{1, 0}, Point{1, 0}, Point{-2, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{1, 6, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 6, Point{3, 3}, []Point{Point{1, 0}, Point{0, 1}, Point{1, 0}, Point{-2, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 6, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 0, Point{4, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - Piece{1, 0, Point{2, 4}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{0, 1}, Point{0, 1}}, nil, nil}, - Piece{2, 0, Point{4, 2}, []Point{Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 0, Point{2, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 2, Point{4, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{1, 2, Point{2, 4}, []Point{Point{1, 0}, Point{0, 1}, Point{-1, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 2, Point{4, 2}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 2, Point{2, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{-1, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 1, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{1, 1, Point{3, 3}, []Point{Point{2, 0}, Point{-1, 1}, Point{1, 0}, Point{-2, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 1, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 1, Point{3, 3}, []Point{Point{1, 0}, Point{1, 0}, Point{-2, 1}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 3, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{-1, 1}, Point{0, 1}}, nil, nil}, - Piece{1, 3, Point{3, 3}, []Point{Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 3, Point{3, 3}, []Point{Point{1, 0}, Point{0, 1}, Point{-1, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{3, 3, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - - Piece{0, 4, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{1, 4, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{2, 4, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - Piece{3, 4, Point{3, 3}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 8, Point{4, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 8, Point{2, 4}, []Point{Point{1, 0}, Point{-1, 1}, Point{1, 0}, Point{-1, 1}, Point{0, 1}}, nil, nil}, - Piece{2, 8, Point{4, 2}, []Point{Point{0, 0}, Point{1, 0}, Point{1, 0}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 8, Point{2, 4}, []Point{Point{1, 0}, Point{0, 1}, Point{-1, 1}, Point{1, 0}, Point{-1, 1}}, nil, nil}, - - Piece{0, 9, Point{4, 2}, []Point{Point{2, 0}, Point{1, 0}, Point{-3, 1}, Point{1, 0}, Point{1, 0}}, nil, nil}, - Piece{1, 9, Point{2, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{2, 9, Point{4, 2}, []Point{Point{1, 0}, Point{1, 0}, Point{1, 0}, Point{-3, 1}, Point{1, 0}}, nil, nil}, - Piece{3, 9, Point{2, 4}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{0, 1}, Point{0, 1}}, nil, nil}, - - Piece{0, 5, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{1, 5, Point{3, 3}, []Point{Point{1, 0}, Point{1, 0}, Point{-1, 1}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 5, Point{3, 3}, []Point{Point{0, 0}, Point{0, 1}, Point{1, 0}, Point{1, 0}, Point{0, 1}}, nil, nil}, - Piece{3, 5, Point{3, 3}, []Point{Point{1, 0}, Point{1, 0}, Point{-1, 1}, Point{-1, 1}, Point{1, 0}}, nil, nil}, - - Piece{0, 6, Point{3, 3}, []Point{Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - Piece{1, 6, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}}, nil, nil}, - Piece{2, 6, Point{3, 3}, []Point{Point{2, 0}, Point{-2, 1}, Point{1, 0}, Point{1, 0}, Point{-2, 1}}, nil, nil}, - Piece{3, 6, Point{3, 3}, []Point{Point{0, 0}, Point{1, 0}, Point{0, 1}, Point{0, 1}, Point{1, 0}}, nil, nil}, -} diff --git a/src/pkg/exp/4s/xs.go b/src/pkg/exp/4s/xs.go deleted file mode 100644 index c5493e719..000000000 --- a/src/pkg/exp/4s/xs.go +++ /dev/null @@ -1,742 +0,0 @@ -// games/4s - a tetris clone -// -// Derived from Plan 9's /sys/src/games/xs.c -// http://plan9.bell-labs.com/sources/plan9/sys/src/games/xs.c -// -// Copyright (C) 2003, Lucent Technologies Inc. and others. All Rights Reserved. -// Portions Copyright 2009 The Go Authors. All Rights Reserved. -// Distributed under the terms of the Lucent Public License Version 1.02 -// See http://plan9.bell-labs.com/plan9/license.html - -/* - * engine for 4s, 5s, etc - */ - -package main - -import ( - "exp/draw" - "image" - "log" - "os" - "rand" - "time" -) - -/* -Cursor whitearrow = { - {0, 0}, - {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, - 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC, - 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, - 0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }, - {0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C, - 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C, - 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C, - 0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, } -}; -*/ - -const ( - CNone = 0 - CBounds = 1 - CPiece = 2 - NX = 10 - NY = 20 - - NCOL = 10 - - MAXN = 5 -) - -var ( - N int - display draw.Context - screen draw.Image - screenr draw.Rectangle - board [NY][NX]byte - rboard draw.Rectangle - pscore draw.Point - scoresz draw.Point - pcsz = 32 - pos draw.Point - bbr, bb2r draw.Rectangle - bb, bbmask, bb2, bb2mask *image.RGBA - whitemask image.Image - br, br2 draw.Rectangle - points int - dt int - DY int - DMOUSE int - lastmx int - mouse draw.Mouse - newscreen bool - timerc <-chan int64 - suspc chan bool - mousec chan draw.Mouse - resizec <-chan bool - kbdc chan int - suspended bool - tsleep int - piece *Piece - pieces []Piece -) - -type Piece struct { - rot int - tx int - sz draw.Point - d []draw.Point - left *Piece - right *Piece -} - -var txbits = [NCOL][32]byte{ - [32]byte{0xDD, 0xDD, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, - 0xDD, 0xDD, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, - 0xDD, 0xDD, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, - 0xDD, 0xDD, 0xFF, 0xFF, 0x77, 0x77, 0xFF, 0xFF, - }, - [32]byte{0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77, - 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77, - 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77, - 0xDD, 0xDD, 0x77, 0x77, 0xDD, 0xDD, 0x77, 0x77, - }, - [32]byte{0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - }, - [32]byte{0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - 0xAA, 0xAA, 0x55, 0x55, 0xAA, 0xAA, 0x55, 0x55, - }, - [32]byte{0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88, - 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88, - 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88, - 0x22, 0x22, 0x88, 0x88, 0x22, 0x22, 0x88, 0x88, - }, - [32]byte{0x22, 0x22, 0x00, 0x00, 0x88, 0x88, 0x00, 0x00, - 0x22, 0x22, 0x00, 0x00, 0x88, 0x88, 0x00, 0x00, - 0x22, 0x22, 0x00, 0x00, 0x88, 0x88, 0x00, 0x00, - 0x22, 0x22, 0x00, 0x00, 0x88, 0x88, 0x00, 0x00, - }, - [32]byte{0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - }, - [32]byte{0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, - }, - [32]byte{0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, - 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, - 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, - 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, - }, - [32]byte{0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0x33, 0x33, 0x33, - 0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0x33, 0x33, 0x33, - 0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0x33, 0x33, 0x33, - 0xCC, 0xCC, 0xCC, 0xCC, 0x33, 0x33, 0x33, 0x33, - }, -} - -var txpix = [NCOL]draw.Color{ - draw.Yellow, /* yellow */ - draw.Cyan, /* cyan */ - draw.Green, /* lime green */ - draw.GreyBlue, /* slate */ - draw.Red, /* red */ - draw.GreyGreen, /* olive green */ - draw.Blue, /* blue */ - draw.Color(0xFF55AAFF), /* pink */ - draw.Color(0xFFAAFFFF), /* lavender */ - draw.Color(0xBB005DFF), /* maroon */ -} - -func movemouse() int { - //mouse.draw.Point = draw.Pt(rboard.Min.X + rboard.Dx()/2, rboard.Min.Y + rboard.Dy()/2); - //moveto(mousectl, mouse.Xy); - return mouse.X -} - -func warp(p draw.Point, x int) int { - if !suspended && piece != nil { - x = pos.X + piece.sz.X*pcsz/2 - if p.Y < rboard.Min.Y { - p.Y = rboard.Min.Y - } - if p.Y >= rboard.Max.Y { - p.Y = rboard.Max.Y - 1 - } - //moveto(mousectl, draw.Pt(x, p.Y)); - } - return x -} - -func initPieces() { - for i := range pieces { - p := &pieces[i] - if p.rot == 3 { - p.right = &pieces[i-3] - } else { - p.right = &pieces[i+1] - } - if p.rot == 0 { - p.left = &pieces[i+3] - } else { - p.left = &pieces[i-1] - } - } -} - -func collide(pt draw.Point, p *Piece) bool { - pt.X = (pt.X - rboard.Min.X) / pcsz - pt.Y = (pt.Y - rboard.Min.Y) / pcsz - for _, q := range p.d { - pt.X += q.X - pt.Y += q.Y - if pt.X < 0 || pt.X >= NX || pt.Y < 0 || pt.Y >= NY { - return true - continue - } - if board[pt.Y][pt.X] != 0 { - return true - } - } - return false -} - -func collider(pt, pmax draw.Point) bool { - pi := (pt.X - rboard.Min.X) / pcsz - pj := (pt.Y - rboard.Min.Y) / pcsz - n := pmax.X / pcsz - m := pmax.Y/pcsz + 1 - for i := pi; i < pi+n && i < NX; i++ { - for j := pj; j < pj+m && j < NY; j++ { - if board[j][i] != 0 { - return true - } - } - } - return false -} - -func setpiece(p *Piece) { - draw.Draw(bb, bbr, draw.White, draw.ZP) - draw.Draw(bbmask, bbr, draw.Transparent, draw.ZP) - br = draw.Rect(0, 0, 0, 0) - br2 = br - piece = p - if p == nil { - return - } - var op draw.Point - var r draw.Rectangle - r.Min = bbr.Min - for i, pt := range p.d { - r.Min.X += pt.X * pcsz - r.Min.Y += pt.Y * pcsz - r.Max.X = r.Min.X + pcsz - r.Max.Y = r.Min.Y + pcsz - if i == 0 { - draw.Draw(bb, r, draw.Black, draw.ZP) - draw.Draw(bb, r.Inset(1), txpix[piece.tx], draw.ZP) - draw.Draw(bbmask, r, draw.Opaque, draw.ZP) - op = r.Min - } else { - draw.Draw(bb, r, bb, op) - draw.Draw(bbmask, r, bbmask, op) - } - if br.Max.X < r.Max.X { - br.Max.X = r.Max.X - } - if br.Max.Y < r.Max.Y { - br.Max.Y = r.Max.Y - } - } - br.Max = br.Max.Sub(bbr.Min) - delta := draw.Pt(0, DY) - br2.Max = br.Max.Add(delta) - r = br.Add(bb2r.Min) - r2 := br2.Add(bb2r.Min) - draw.Draw(bb2, r2, draw.White, draw.ZP) - draw.Draw(bb2, r.Add(delta), bb, bbr.Min) - draw.Draw(bb2mask, r2, draw.Transparent, draw.ZP) - draw.DrawMask(bb2mask, r, draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.Over) - draw.DrawMask(bb2mask, r.Add(delta), draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.Over) -} - -func drawpiece() { - draw.DrawMask(screen, br.Add(pos), bb, bbr.Min, bbmask, draw.ZP, draw.Over) - if suspended { - draw.DrawMask(screen, br.Add(pos), draw.White, draw.ZP, whitemask, draw.ZP, draw.Over) - } -} - -func undrawpiece() { - var mask image.Image - if collider(pos, br.Max) { - mask = bbmask - } - draw.DrawMask(screen, br.Add(pos), draw.White, bbr.Min, mask, bbr.Min, draw.Over) -} - -func rest() { - pt := pos.Sub(rboard.Min).Div(pcsz) - for _, p := range piece.d { - pt.X += p.X - pt.Y += p.Y - board[pt.Y][pt.X] = byte(piece.tx + 16) - } -} - -func canfit(p *Piece) bool { - var dx = [...]int{0, -1, 1, -2, 2, -3, 3, 4, -4} - j := N + 1 - if j >= 4 { - j = p.sz.X - if j < p.sz.Y { - j = p.sz.Y - } - j = 2*j - 1 - } - for i := 0; i < j; i++ { - var z draw.Point - z.X = pos.X + dx[i]*pcsz - z.Y = pos.Y - if !collide(z, p) { - z.Y = pos.Y + pcsz - 1 - if !collide(z, p) { - undrawpiece() - pos.X = z.X - return true - } - } - } - return false -} - -func score(p int) { - points += p - // snprint(buf, sizeof(buf), "%.6ld", points); - // draw.Draw(screen, draw.Rpt(pscore, pscore.Add(scoresz)), draw.White, draw.ZP); - // string(screen, pscore, draw.Black, draw.ZP, font, buf); -} - -func drawsq(b draw.Image, p draw.Point, ptx int) { - var r draw.Rectangle - r.Min = p - r.Max.X = r.Min.X + pcsz - r.Max.Y = r.Min.Y + pcsz - draw.Draw(b, r, draw.Black, draw.ZP) - draw.Draw(b, r.Inset(1), txpix[ptx], draw.ZP) -} - -func drawboard() { - draw.Border(screen, rboard.Inset(-2), 2, draw.Black, draw.ZP) - draw.Draw(screen, draw.Rect(rboard.Min.X, rboard.Min.Y-2, rboard.Max.X, rboard.Min.Y), - draw.White, draw.ZP) - for i := 0; i < NY; i++ { - for j := 0; j < NX; j++ { - if board[i][j] != 0 { - drawsq(screen, draw.Pt(rboard.Min.X+j*pcsz, rboard.Min.Y+i*pcsz), int(board[i][j]-16)) - } - } - } - score(0) - if suspended { - draw.DrawMask(screen, screenr, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over) - } -} - -func choosepiece() { - for { - i := rand.Intn(len(pieces)) - setpiece(&pieces[i]) - pos = rboard.Min - pos.X += rand.Intn(NX) * pcsz - if !collide(draw.Pt(pos.X, pos.Y+pcsz-DY), piece) { - break - } - } - drawpiece() - display.FlushImage() -} - -func movepiece() bool { - var mask image.Image - if collide(draw.Pt(pos.X, pos.Y+pcsz), piece) { - return false - } - if collider(pos, br2.Max) { - mask = bb2mask - } - draw.DrawMask(screen, br2.Add(pos), bb2, bb2r.Min, mask, bb2r.Min, draw.Over) - pos.Y += DY - display.FlushImage() - return true -} - -func suspend(s bool) { - suspended = s - /* - if suspended { - setcursor(mousectl, &whitearrow); - } else { - setcursor(mousectl, nil); - } - */ - if !suspended { - drawpiece() - } - drawboard() - display.FlushImage() -} - -func pause(t int) { - display.FlushImage() - for { - select { - case s := <-suspc: - if !suspended && s { - suspend(true) - } else if suspended && !s { - suspend(false) - lastmx = warp(mouse.Point, lastmx) - } - case <-timerc: - if suspended { - break - } - t -= tsleep - if t < 0 { - return - } - case <-resizec: - //redraw(true); - case mouse = <-mousec: - case <-kbdc: - } - } -} - -func horiz() bool { - var lev [MAXN]int - h := 0 - for i := 0; i < NY; i++ { - for j := 0; board[i][j] != 0; j++ { - if j == NX-1 { - lev[h] = i - h++ - break - } - } - } - if h == 0 { - return false - } - r := rboard - newscreen = false - for j := 0; j < h; j++ { - r.Min.Y = rboard.Min.Y + lev[j]*pcsz - r.Max.Y = r.Min.Y + pcsz - draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over) - display.FlushImage() - } - PlaySound(whoosh) - for i := 0; i < 3; i++ { - pause(250) - if newscreen { - drawboard() - break - } - for j := 0; j < h; j++ { - r.Min.Y = rboard.Min.Y + lev[j]*pcsz - r.Max.Y = r.Min.Y + pcsz - draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over) - } - display.FlushImage() - } - r = rboard - for j := 0; j < h; j++ { - i := NY - lev[j] - 1 - score(250 + 10*i*i) - r.Min.Y = rboard.Min.Y - r.Max.Y = rboard.Min.Y + lev[j]*pcsz - draw.Draw(screen, r.Add(draw.Pt(0, pcsz)), screen, r.Min) - r.Max.Y = rboard.Min.Y + pcsz - draw.Draw(screen, r, draw.White, draw.ZP) - for k := lev[j] - 1; k >= 0; k-- { - board[k+1] = board[k] - } - board[0] = [NX]byte{} - } - display.FlushImage() - return true -} - -func mright() { - if !collide(draw.Pt(pos.X+pcsz, pos.Y), piece) && - !collide(draw.Pt(pos.X+pcsz, pos.Y+pcsz-DY), piece) { - undrawpiece() - pos.X += pcsz - drawpiece() - display.FlushImage() - } -} - -func mleft() { - if !collide(draw.Pt(pos.X-pcsz, pos.Y), piece) && - !collide(draw.Pt(pos.X-pcsz, pos.Y+pcsz-DY), piece) { - undrawpiece() - pos.X -= pcsz - drawpiece() - display.FlushImage() - } -} - -func rright() { - if canfit(piece.right) { - setpiece(piece.right) - drawpiece() - display.FlushImage() - } -} - -func rleft() { - if canfit(piece.left) { - setpiece(piece.left) - drawpiece() - display.FlushImage() - } -} - -var fusst = 0 - -func drop(f bool) bool { - if f { - score(5 * (rboard.Max.Y - pos.Y) / pcsz) - for movepiece() { - } - } - fusst = 0 - rest() - if pos.Y == rboard.Min.Y && !horiz() { - return true - } - horiz() - setpiece(nil) - pause(1500) - choosepiece() - lastmx = warp(mouse.Point, lastmx) - return false -} - -func play() { - var om draw.Mouse - dt = 64 - lastmx = -1 - lastmx = movemouse() - choosepiece() - lastmx = warp(mouse.Point, lastmx) - for { - select { - case mouse = <-mousec: - if suspended { - om = mouse - break - } - if lastmx < 0 { - lastmx = mouse.X - } - if mouse.X > lastmx+DMOUSE { - mright() - lastmx = mouse.X - } - if mouse.X < lastmx-DMOUSE { - mleft() - lastmx = mouse.X - } - if mouse.Buttons&^om.Buttons&1 == 1 { - rleft() - } - if mouse.Buttons&^om.Buttons&2 == 2 { - if drop(true) { - return - } - } - if mouse.Buttons&^om.Buttons&4 == 4 { - rright() - } - om = mouse - - case s := <-suspc: - if !suspended && s { - suspend(true) - } else if suspended && !s { - suspend(false) - lastmx = warp(mouse.Point, lastmx) - } - - case <-resizec: - //redraw(true); - - case r := <-kbdc: - if suspended { - break - } - switch r { - case 'f', ';': - mright() - case 'a', 'j': - mleft() - case 'd', 'l': - rright() - case 's', 'k': - rleft() - case ' ': - if drop(true) { - return - } - } - - case <-timerc: - if suspended { - break - } - dt -= tsleep - if dt < 0 { - i := 1 - dt = 16 * (points + rand.Intn(10000) - 5000) / 10000 - if dt >= 32 { - i += (dt - 32) / 16 - dt = 32 - } - dt = 52 - dt - for ; i > 0; i-- { - if movepiece() { - continue - } - fusst++ - if fusst == 40 { - if drop(false) { - return - } - break - } - } - } - } - } -} - -func suspproc() { - mc := display.MouseChan() - kc := display.KeyboardChan() - - s := false - for { - select { - case mouse = <-mc: - mousec <- mouse - case r := <-kc: - switch r { - case 'q', 'Q', 0x04, 0x7F: - os.Exit(0) - default: - if s { - s = false - suspc <- s - break - } - switch r { - case 'z', 'Z', 'p', 'P', 0x1B: - s = true - suspc <- s - default: - kbdc <- r - } - } - } - } -} - -func redraw(new bool) { - // if new && getwindow(display, Refmesg) < 0 { - // sysfatal("can't reattach to window"); - // } - r := draw.Rect(0, 0, screen.Width(), screen.Height()) - pos.X = (pos.X - rboard.Min.X) / pcsz - pos.Y = (pos.Y - rboard.Min.Y) / pcsz - dx := r.Max.X - r.Min.X - dy := r.Max.Y - r.Min.Y - 2*32 - DY = dx / NX - if DY > dy/NY { - DY = dy / NY - } - DY /= 8 - if DY > 4 { - DY = 4 - } - pcsz = DY * 8 - DMOUSE = pcsz / 3 - if pcsz < 8 { - log.Exitf("screen too small: %d", pcsz) - } - rboard = screenr - rboard.Min.X += (dx - pcsz*NX) / 2 - rboard.Min.Y += (dy-pcsz*NY)/2 + 32 - rboard.Max.X = rboard.Min.X + NX*pcsz - rboard.Max.Y = rboard.Min.Y + NY*pcsz - pscore.X = rboard.Min.X + 8 - pscore.Y = rboard.Min.Y - 32 - // scoresz = stringsize(font, "000000"); - pos.X = pos.X*pcsz + rboard.Min.X - pos.Y = pos.Y*pcsz + rboard.Min.Y - bbr = draw.Rect(0, 0, N*pcsz, N*pcsz) - bb = image.NewRGBA(bbr.Max.X, bbr.Max.Y) - bbmask = image.NewRGBA(bbr.Max.X, bbr.Max.Y) // actually just a bitmap - bb2r = draw.Rect(0, 0, N*pcsz, N*pcsz+DY) - bb2 = image.NewRGBA(bb2r.Dx(), bb2r.Dy()) - bb2mask = image.NewRGBA(bb2r.Dx(), bb2r.Dy()) // actually just a bitmap - draw.Draw(screen, screenr, draw.White, draw.ZP) - drawboard() - setpiece(piece) - if piece != nil { - drawpiece() - } - lastmx = movemouse() - newscreen = true - display.FlushImage() -} - -func quitter(c <-chan bool) { - <-c - os.Exit(0) -} - -func Play(pp []Piece, ctxt draw.Context) { - display = ctxt - screen = ctxt.Screen() - screenr = draw.Rect(0, 0, screen.Width(), screen.Height()) - pieces = pp - N = len(pieces[0].d) - initPieces() - rand.Seed(int64(time.Nanoseconds() % (1e9 - 1))) - whitemask = draw.White.SetAlpha(0x7F) - tsleep = 50 - timerc = time.Tick(int64(tsleep/2) * 1e6) - suspc = make(chan bool) - mousec = make(chan draw.Mouse) - resizec = ctxt.ResizeChan() - kbdc = make(chan int) - go quitter(ctxt.QuitChan()) - go suspproc() - points = 0 - redraw(false) - play() -} diff --git a/src/pkg/exp/bignum/Makefile b/src/pkg/exp/bignum/Makefile deleted file mode 100644 index 064cf1eb9..000000000 --- a/src/pkg/exp/bignum/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -include ../../../Make.$(GOARCH) - -TARG=exp/bignum -GOFILES=\ - arith.go\ - bignum.go\ - integer.go\ - rational.go\ - -include ../../../Make.pkg diff --git a/src/pkg/exp/bignum/arith.go b/src/pkg/exp/bignum/arith.go deleted file mode 100644 index aa65dbd7a..000000000 --- a/src/pkg/exp/bignum/arith.go +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Fast versions of the routines in this file are in fast.arith.s. -// Simply replace this file with arith.s (renamed from fast.arith.s) -// and the bignum package will build and run on a platform that -// supports the assembly routines. - -package bignum - -import "unsafe" - -// z1<<64 + z0 = x*y -func Mul128(x, y uint64) (z1, z0 uint64) { - // Split x and y into 2 halfwords each, multiply - // the halfwords separately while avoiding overflow, - // and return the product as 2 words. - - const ( - W = uint(unsafe.Sizeof(x)) * 8 - W2 = W / 2 - B2 = 1 << W2 - M2 = B2 - 1 - ) - - if x < y { - x, y = y, x - } - - if x < B2 { - // y < B2 because y <= x - // sub-digits of x and y are (0, x) and (0, y) - // z = z[0] = x*y - z0 = x * y - return - } - - if y < B2 { - // sub-digits of x and y are (x1, x0) and (0, y) - // x = (x1*B2 + x0) - // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2 - - // x*y = t2*B2*B2 + t1*B2 + t0 - t0 := x0 * y - t1 := x1 * y - - // compute result digits but avoid overflow - // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0 - z1 = (t1 + t0>>W2) >> W2 - return - } - - // general case - // sub-digits of x and y are (x1, x0) and (y1, y0) - // x = (x1*B2 + x0) - // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2 - y1, y0 := y>>W2, y&M2 - - // x*y = t2*B2*B2 + t1*B2 + t0 - t0 := x0 * y0 - t1 := x1*y0 + x0*y1 - t2 := x1 * y1 - - // compute result digits but avoid overflow - // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0 - z1 = t2 + (t1+t0>>W2)>>W2 - return -} - - -// z1<<64 + z0 = x*y + c -func MulAdd128(x, y, c uint64) (z1, z0 uint64) { - // Split x and y into 2 halfwords each, multiply - // the halfwords separately while avoiding overflow, - // and return the product as 2 words. - - const ( - W = uint(unsafe.Sizeof(x)) * 8 - W2 = W / 2 - B2 = 1 << W2 - M2 = B2 - 1 - ) - - // TODO(gri) Should implement special cases for faster execution. - - // general case - // sub-digits of x, y, and c are (x1, x0), (y1, y0), (c1, c0) - // x = (x1*B2 + x0) - // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2 - y1, y0 := y>>W2, y&M2 - c1, c0 := c>>W2, c&M2 - - // x*y + c = t2*B2*B2 + t1*B2 + t0 - t0 := x0*y0 + c0 - t1 := x1*y0 + x0*y1 + c1 - t2 := x1 * y1 - - // compute result digits but avoid overflow - // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0 - z1 = t2 + (t1+t0>>W2)>>W2 - return -} - - -// q = (x1<<64 + x0)/y + r -func Div128(x1, x0, y uint64) (q, r uint64) { - if x1 == 0 { - q, r = x0/y, x0%y - return - } - - // TODO(gri) Implement general case. - panic("Div128 not implemented for x > 1<<64-1") -} diff --git a/src/pkg/exp/bignum/arith_amd64.s b/src/pkg/exp/bignum/arith_amd64.s deleted file mode 100644 index 37d5a30de..000000000 --- a/src/pkg/exp/bignum/arith_amd64.s +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file provides fast assembly versions -// of the routines in arith.go. - -// func Mul128(x, y uint64) (z1, z0 uint64) -// z1<<64 + z0 = x*y -// -TEXT ·Mul128(SB),7,$0 - MOVQ a+0(FP), AX - MULQ a+8(FP) - MOVQ DX, a+16(FP) - MOVQ AX, a+24(FP) - RET - - -// func MulAdd128(x, y, c uint64) (z1, z0 uint64) -// z1<<64 + z0 = x*y + c -// -TEXT ·MulAdd128(SB),7,$0 - MOVQ a+0(FP), AX - MULQ a+8(FP) - ADDQ a+16(FP), AX - ADCQ $0, DX - MOVQ DX, a+24(FP) - MOVQ AX, a+32(FP) - RET - - -// func Div128(x1, x0, y uint64) (q, r uint64) -// q = (x1<<64 + x0)/y + r -// -TEXT ·Div128(SB),7,$0 - MOVQ a+0(FP), DX - MOVQ a+8(FP), AX - DIVQ a+16(FP) - MOVQ AX, a+24(FP) - MOVQ DX, a+32(FP) - RET diff --git a/src/pkg/exp/bignum/bignum.go b/src/pkg/exp/bignum/bignum.go deleted file mode 100644 index 485583199..000000000 --- a/src/pkg/exp/bignum/bignum.go +++ /dev/null @@ -1,1024 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// A package for arbitrary precision arithmethic. -// It implements the following numeric types: -// -// - Natural unsigned integers -// - Integer signed integers -// - Rational rational numbers -// -// This package has been designed for ease of use but the functions it provides -// are likely to be quite slow. It may be deprecated eventually. Use package -// big instead, if possible. -// -package bignum - -import ( - "fmt" -) - -// TODO(gri) Complete the set of in-place operations. - -// ---------------------------------------------------------------------------- -// Internal representation -// -// A natural number of the form -// -// x = x[n-1]*B^(n-1) + x[n-2]*B^(n-2) + ... + x[1]*B + x[0] -// -// with 0 <= x[i] < B and 0 <= i < n is stored in a slice of length n, -// with the digits x[i] as the slice elements. -// -// A natural number is normalized if the slice contains no leading 0 digits. -// During arithmetic operations, denormalized values may occur but are -// always normalized before returning the final result. The normalized -// representation of 0 is the empty slice (length = 0). -// -// The operations for all other numeric types are implemented on top of -// the operations for natural numbers. -// -// The base B is chosen as large as possible on a given platform but there -// are a few constraints besides the size of the largest unsigned integer -// type available: -// -// 1) To improve conversion speed between strings and numbers, the base B -// is chosen such that division and multiplication by 10 (for decimal -// string representation) can be done without using extended-precision -// arithmetic. This makes addition, subtraction, and conversion routines -// twice as fast. It requires a ``buffer'' of 4 bits per operand digit. -// That is, the size of B must be 4 bits smaller then the size of the -// type (digit) in which these operations are performed. Having this -// buffer also allows for trivial (single-bit) carry computation in -// addition and subtraction (optimization suggested by Ken Thompson). -// -// 2) Long division requires extended-precision (2-digit) division per digit. -// Instead of sacrificing the largest base type for all other operations, -// for division the operands are unpacked into ``half-digits'', and the -// results are packed again. For faster unpacking/packing, the base size -// in bits must be even. - -type ( - digit uint64 - digit2 uint32 // half-digits for division -) - - -const ( - logW = 64 // word width - logH = 4 // bits for a hex digit (= small number) - logB = logW - logH // largest bit-width available - - // half-digits - _W2 = logB / 2 // width - _B2 = 1 << _W2 // base - _M2 = _B2 - 1 // mask - - // full digits - _W = _W2 * 2 // width - _B = 1 << _W // base - _M = _B - 1 // mask -) - - -// ---------------------------------------------------------------------------- -// Support functions - -func assert(p bool) { - if !p { - panic("assert failed") - } -} - - -func isSmall(x digit) bool { return x < 1<<logH } - - -// For debugging. Keep around. -/* -func dump(x Natural) { - print("[", len(x), "]"); - for i := len(x) - 1; i >= 0; i-- { - print(" ", x[i]); - } - println(); -} -*/ - - -// ---------------------------------------------------------------------------- -// Natural numbers - -// Natural represents an unsigned integer value of arbitrary precision. -// -type Natural []digit - - -// Nat creates a small natural number with value x. -// -func Nat(x uint64) Natural { - if x == 0 { - return nil // len == 0 - } - - // single-digit values - // (note: cannot re-use preallocated values because - // the in-place operations may overwrite them) - if x < _B { - return Natural{digit(x)} - } - - // compute number of digits required to represent x - // (this is usually 1 or 2, but the algorithm works - // for any base) - n := 0 - for t := x; t > 0; t >>= _W { - n++ - } - - // split x into digits - z := make(Natural, n) - for i := 0; i < n; i++ { - z[i] = digit(x & _M) - x >>= _W - } - - return z -} - - -// Value returns the lowest 64bits of x. -// -func (x Natural) Value() uint64 { - // single-digit values - n := len(x) - switch n { - case 0: - return 0 - case 1: - return uint64(x[0]) - } - - // multi-digit values - // (this is usually 1 or 2, but the algorithm works - // for any base) - z := uint64(0) - s := uint(0) - for i := 0; i < n && s < 64; i++ { - z += uint64(x[i]) << s - s += _W - } - - return z -} - - -// Predicates - -// IsEven returns true iff x is divisible by 2. -// -func (x Natural) IsEven() bool { return len(x) == 0 || x[0]&1 == 0 } - - -// IsOdd returns true iff x is not divisible by 2. -// -func (x Natural) IsOdd() bool { return len(x) > 0 && x[0]&1 != 0 } - - -// IsZero returns true iff x == 0. -// -func (x Natural) IsZero() bool { return len(x) == 0 } - - -// Operations -// -// Naming conventions -// -// c carry -// x, y operands -// z result -// n, m len(x), len(y) - -func normalize(x Natural) Natural { - n := len(x) - for n > 0 && x[n-1] == 0 { - n-- - } - return x[0:n] -} - - -// nalloc returns a Natural of n digits. If z is large -// enough, z is resized and returned. Otherwise, a new -// Natural is allocated. -// -func nalloc(z Natural, n int) Natural { - size := n - if size <= 0 { - size = 4 - } - if size <= cap(z) { - return z[0:n] - } - return make(Natural, n, size) -} - - -// Nadd sets *zp to the sum x + y. -// *zp may be x or y. -// -func Nadd(zp *Natural, x, y Natural) { - n := len(x) - m := len(y) - if n < m { - Nadd(zp, y, x) - return - } - - z := nalloc(*zp, n+1) - c := digit(0) - i := 0 - for i < m { - t := c + x[i] + y[i] - c, z[i] = t>>_W, t&_M - i++ - } - for i < n { - t := c + x[i] - c, z[i] = t>>_W, t&_M - i++ - } - if c != 0 { - z[i] = c - i++ - } - *zp = z[0:i] -} - - -// Add returns the sum z = x + y. -// -func (x Natural) Add(y Natural) Natural { - var z Natural - Nadd(&z, x, y) - return z -} - - -// Nsub sets *zp to the difference x - y for x >= y. -// If x < y, an underflow run-time error occurs (use Cmp to test if x >= y). -// *zp may be x or y. -// -func Nsub(zp *Natural, x, y Natural) { - n := len(x) - m := len(y) - if n < m { - panic("underflow") - } - - z := nalloc(*zp, n) - c := digit(0) - i := 0 - for i < m { - t := c + x[i] - y[i] - c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift! - i++ - } - for i < n { - t := c + x[i] - c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift! - i++ - } - if int64(c) < 0 { - panic("underflow") - } - *zp = normalize(z) -} - - -// Sub returns the difference x - y for x >= y. -// If x < y, an underflow run-time error occurs (use Cmp to test if x >= y). -// -func (x Natural) Sub(y Natural) Natural { - var z Natural - Nsub(&z, x, y) - return z -} - - -// Returns z1 = (x*y + c) div B, z0 = (x*y + c) mod B. -// -func muladd11(x, y, c digit) (digit, digit) { - z1, z0 := MulAdd128(uint64(x), uint64(y), uint64(c)) - return digit(z1<<(64-logB) | z0>>logB), digit(z0 & _M) -} - - -func mul1(z, x Natural, y digit) (c digit) { - for i := 0; i < len(x); i++ { - c, z[i] = muladd11(x[i], y, c) - } - return -} - - -// Nscale sets *z to the scaled value (*z) * d. -// -func Nscale(z *Natural, d uint64) { - switch { - case d == 0: - *z = Nat(0) - return - case d == 1: - return - case d >= _B: - *z = z.Mul1(d) - return - } - - c := mul1(*z, *z, digit(d)) - - if c != 0 { - n := len(*z) - if n >= cap(*z) { - zz := make(Natural, n+1) - for i, d := range *z { - zz[i] = d - } - *z = zz - } else { - *z = (*z)[0 : n+1] - } - (*z)[n] = c - } -} - - -// Computes x = x*d + c for small d's. -// -func muladd1(x Natural, d, c digit) Natural { - assert(isSmall(d-1) && isSmall(c)) - n := len(x) - z := make(Natural, n+1) - - for i := 0; i < n; i++ { - t := c + x[i]*d - c, z[i] = t>>_W, t&_M - } - z[n] = c - - return normalize(z) -} - - -// Mul1 returns the product x * d. -// -func (x Natural) Mul1(d uint64) Natural { - switch { - case d == 0: - return Nat(0) - case d == 1: - return x - case isSmall(digit(d)): - muladd1(x, digit(d), 0) - case d >= _B: - return x.Mul(Nat(d)) - } - - z := make(Natural, len(x)+1) - c := mul1(z, x, digit(d)) - z[len(x)] = c - return normalize(z) -} - - -// Mul returns the product x * y. -// -func (x Natural) Mul(y Natural) Natural { - n := len(x) - m := len(y) - if n < m { - return y.Mul(x) - } - - if m == 0 { - return Nat(0) - } - - if m == 1 && y[0] < _B { - return x.Mul1(uint64(y[0])) - } - - z := make(Natural, n+m) - for j := 0; j < m; j++ { - d := y[j] - if d != 0 { - c := digit(0) - for i := 0; i < n; i++ { - c, z[i+j] = muladd11(x[i], d, z[i+j]+c) - } - z[n+j] = c - } - } - - return normalize(z) -} - - -// DivMod needs multi-precision division, which is not available if digit -// is already using the largest uint size. Instead, unpack each operand -// into operands with twice as many digits of half the size (digit2), do -// DivMod, and then pack the results again. - -func unpack(x Natural) []digit2 { - n := len(x) - z := make([]digit2, n*2+1) // add space for extra digit (used by DivMod) - for i := 0; i < n; i++ { - t := x[i] - z[i*2] = digit2(t & _M2) - z[i*2+1] = digit2(t >> _W2 & _M2) - } - - // normalize result - k := 2 * n - for k > 0 && z[k-1] == 0 { - k-- - } - return z[0:k] // trim leading 0's -} - - -func pack(x []digit2) Natural { - n := (len(x) + 1) / 2 - z := make(Natural, n) - if len(x)&1 == 1 { - // handle odd len(x) - n-- - z[n] = digit(x[n*2]) - } - for i := 0; i < n; i++ { - z[i] = digit(x[i*2+1])<<_W2 | digit(x[i*2]) - } - return normalize(z) -} - - -func mul21(z, x []digit2, y digit2) digit2 { - c := digit(0) - f := digit(y) - for i := 0; i < len(x); i++ { - t := c + digit(x[i])*f - c, z[i] = t>>_W2, digit2(t&_M2) - } - return digit2(c) -} - - -func div21(z, x []digit2, y digit2) digit2 { - c := digit(0) - d := digit(y) - for i := len(x) - 1; i >= 0; i-- { - t := c<<_W2 + digit(x[i]) - c, z[i] = t%d, digit2(t/d) - } - return digit2(c) -} - - -// divmod returns q and r with x = y*q + r and 0 <= r < y. -// x and y are destroyed in the process. -// -// The algorithm used here is based on 1). 2) describes the same algorithm -// in C. A discussion and summary of the relevant theorems can be found in -// 3). 3) also describes an easier way to obtain the trial digit - however -// it relies on tripple-precision arithmetic which is why Knuth's method is -// used here. -// -// 1) D. Knuth, The Art of Computer Programming. Volume 2. Seminumerical -// Algorithms. Addison-Wesley, Reading, 1969. -// (Algorithm D, Sec. 4.3.1) -// -// 2) Henry S. Warren, Jr., Hacker's Delight. Addison-Wesley, 2003. -// (9-2 Multiword Division, p.140ff) -// -// 3) P. Brinch Hansen, ``Multiple-length division revisited: A tour of the -// minefield''. Software - Practice and Experience 24, (June 1994), -// 579-601. John Wiley & Sons, Ltd. - -func divmod(x, y []digit2) ([]digit2, []digit2) { - n := len(x) - m := len(y) - if m == 0 { - panic("division by zero") - } - assert(n+1 <= cap(x)) // space for one extra digit - x = x[0 : n+1] - assert(x[n] == 0) - - if m == 1 { - // division by single digit - // result is shifted left by 1 in place! - x[0] = div21(x[1:n+1], x[0:n], y[0]) - - } else if m > n { - // y > x => quotient = 0, remainder = x - // TODO in this case we shouldn't even unpack x and y - m = n - - } else { - // general case - assert(2 <= m && m <= n) - - // normalize x and y - // TODO Instead of multiplying, it would be sufficient to - // shift y such that the normalization condition is - // satisfied (as done in Hacker's Delight). - f := _B2 / (digit(y[m-1]) + 1) - if f != 1 { - mul21(x, x, digit2(f)) - mul21(y, y, digit2(f)) - } - assert(_B2/2 <= y[m-1] && y[m-1] < _B2) // incorrect scaling - - y1, y2 := digit(y[m-1]), digit(y[m-2]) - for i := n - m; i >= 0; i-- { - k := i + m - - // compute trial digit (Knuth) - var q digit - { - x0, x1, x2 := digit(x[k]), digit(x[k-1]), digit(x[k-2]) - if x0 != y1 { - q = (x0<<_W2 + x1) / y1 - } else { - q = _B2 - 1 - } - for y2*q > (x0<<_W2+x1-y1*q)<<_W2+x2 { - q-- - } - } - - // subtract y*q - c := digit(0) - for j := 0; j < m; j++ { - t := c + digit(x[i+j]) - digit(y[j])*q - c, x[i+j] = digit(int64(t)>>_W2), digit2(t&_M2) // requires arithmetic shift! - } - x[k] = digit2((c + digit(x[k])) & _M2) - - // correct if trial digit was too large - if x[k] != 0 { - // add y - c := digit(0) - for j := 0; j < m; j++ { - t := c + digit(x[i+j]) + digit(y[j]) - c, x[i+j] = t>>_W2, digit2(t&_M2) - } - x[k] = digit2((c + digit(x[k])) & _M2) - assert(x[k] == 0) - // correct trial digit - q-- - } - - x[k] = digit2(q) - } - - // undo normalization for remainder - if f != 1 { - c := div21(x[0:m], x[0:m], digit2(f)) - assert(c == 0) - } - } - - return x[m : n+1], x[0:m] -} - - -// Div returns the quotient q = x / y for y > 0, -// with x = y*q + r and 0 <= r < y. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x Natural) Div(y Natural) Natural { - q, _ := divmod(unpack(x), unpack(y)) - return pack(q) -} - - -// Mod returns the modulus r of the division x / y for y > 0, -// with x = y*q + r and 0 <= r < y. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x Natural) Mod(y Natural) Natural { - _, r := divmod(unpack(x), unpack(y)) - return pack(r) -} - - -// DivMod returns the pair (x.Div(y), x.Mod(y)) for y > 0. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x Natural) DivMod(y Natural) (Natural, Natural) { - q, r := divmod(unpack(x), unpack(y)) - return pack(q), pack(r) -} - - -func shl(z, x Natural, s uint) digit { - assert(s <= _W) - n := len(x) - c := digit(0) - for i := 0; i < n; i++ { - c, z[i] = x[i]>>(_W-s), x[i]<<s&_M|c - } - return c -} - - -// Shl implements ``shift left'' x << s. It returns x * 2^s. -// -func (x Natural) Shl(s uint) Natural { - n := uint(len(x)) - m := n + s/_W - z := make(Natural, m+1) - - z[m] = shl(z[m-n:m], x, s%_W) - - return normalize(z) -} - - -func shr(z, x Natural, s uint) digit { - assert(s <= _W) - n := len(x) - c := digit(0) - for i := n - 1; i >= 0; i-- { - c, z[i] = x[i]<<(_W-s)&_M, x[i]>>s|c - } - return c -} - - -// Shr implements ``shift right'' x >> s. It returns x / 2^s. -// -func (x Natural) Shr(s uint) Natural { - n := uint(len(x)) - m := n - s/_W - if m > n { // check for underflow - m = 0 - } - z := make(Natural, m) - - shr(z, x[n-m:n], s%_W) - - return normalize(z) -} - - -// And returns the ``bitwise and'' x & y for the 2's-complement representation of x and y. -// -func (x Natural) And(y Natural) Natural { - n := len(x) - m := len(y) - if n < m { - return y.And(x) - } - - z := make(Natural, m) - for i := 0; i < m; i++ { - z[i] = x[i] & y[i] - } - // upper bits are 0 - - return normalize(z) -} - - -func copy(z, x Natural) { - for i, e := range x { - z[i] = e - } -} - - -// AndNot returns the ``bitwise clear'' x &^ y for the 2's-complement representation of x and y. -// -func (x Natural) AndNot(y Natural) Natural { - n := len(x) - m := len(y) - if n < m { - m = n - } - - z := make(Natural, n) - for i := 0; i < m; i++ { - z[i] = x[i] &^ y[i] - } - copy(z[m:n], x[m:n]) - - return normalize(z) -} - - -// Or returns the ``bitwise or'' x | y for the 2's-complement representation of x and y. -// -func (x Natural) Or(y Natural) Natural { - n := len(x) - m := len(y) - if n < m { - return y.Or(x) - } - - z := make(Natural, n) - for i := 0; i < m; i++ { - z[i] = x[i] | y[i] - } - copy(z[m:n], x[m:n]) - - return z -} - - -// Xor returns the ``bitwise exclusive or'' x ^ y for the 2's-complement representation of x and y. -// -func (x Natural) Xor(y Natural) Natural { - n := len(x) - m := len(y) - if n < m { - return y.Xor(x) - } - - z := make(Natural, n) - for i := 0; i < m; i++ { - z[i] = x[i] ^ y[i] - } - copy(z[m:n], x[m:n]) - - return normalize(z) -} - - -// Cmp compares x and y. The result is an int value -// -// < 0 if x < y -// == 0 if x == y -// > 0 if x > y -// -func (x Natural) Cmp(y Natural) int { - n := len(x) - m := len(y) - - if n != m || n == 0 { - return n - m - } - - i := n - 1 - for i > 0 && x[i] == y[i] { - i-- - } - - d := 0 - switch { - case x[i] < y[i]: - d = -1 - case x[i] > y[i]: - d = 1 - } - - return d -} - - -// log2 computes the binary logarithm of x for x > 0. -// The result is the integer n for which 2^n <= x < 2^(n+1). -// If x == 0 a run-time error occurs. -// -func log2(x uint64) uint { - assert(x > 0) - n := uint(0) - for x > 0 { - x >>= 1 - n++ - } - return n - 1 -} - - -// Log2 computes the binary logarithm of x for x > 0. -// The result is the integer n for which 2^n <= x < 2^(n+1). -// If x == 0 a run-time error occurs. -// -func (x Natural) Log2() uint { - n := len(x) - if n > 0 { - return (uint(n)-1)*_W + log2(uint64(x[n-1])) - } - panic("Log2(0)") -} - - -// Computes x = x div d in place (modifies x) for small d's. -// Returns updated x and x mod d. -// -func divmod1(x Natural, d digit) (Natural, digit) { - assert(0 < d && isSmall(d-1)) - - c := digit(0) - for i := len(x) - 1; i >= 0; i-- { - t := c<<_W + x[i] - c, x[i] = t%d, t/d - } - - return normalize(x), c -} - - -// ToString converts x to a string for a given base, with 2 <= base <= 16. -// -func (x Natural) ToString(base uint) string { - if len(x) == 0 { - return "0" - } - - // allocate buffer for conversion - assert(2 <= base && base <= 16) - n := (x.Log2()+1)/log2(uint64(base)) + 1 // +1: round up - s := make([]byte, n) - - // don't destroy x - t := make(Natural, len(x)) - copy(t, x) - - // convert - i := n - for !t.IsZero() { - i-- - var d digit - t, d = divmod1(t, digit(base)) - s[i] = "0123456789abcdef"[d] - } - - return string(s[i:n]) -} - - -// String converts x to its decimal string representation. -// x.String() is the same as x.ToString(10). -// -func (x Natural) String() string { return x.ToString(10) } - - -func fmtbase(c int) uint { - switch c { - case 'b': - return 2 - case 'o': - return 8 - case 'x': - return 16 - } - return 10 -} - - -// Format is a support routine for fmt.Formatter. It accepts -// the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). -// -func (x Natural) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } - - -func hexvalue(ch byte) uint { - d := uint(1 << logH) - switch { - case '0' <= ch && ch <= '9': - d = uint(ch - '0') - case 'a' <= ch && ch <= 'f': - d = uint(ch-'a') + 10 - case 'A' <= ch && ch <= 'F': - d = uint(ch-'A') + 10 - } - return d -} - - -// NatFromString returns the natural number corresponding to the -// longest possible prefix of s representing a natural number in a -// given conversion base, the actual conversion base used, and the -// prefix length. The syntax of natural numbers follows the syntax -// of unsigned integer literals in Go. -// -// If the base argument is 0, the string prefix determines the actual -// conversion base. A prefix of ``0x'' or ``0X'' selects base 16; the -// ``0'' prefix selects base 8. Otherwise the selected base is 10. -// -func NatFromString(s string, base uint) (Natural, uint, int) { - // determine base if necessary - i, n := 0, len(s) - if base == 0 { - base = 10 - if n > 0 && s[0] == '0' { - if n > 1 && (s[1] == 'x' || s[1] == 'X') { - base, i = 16, 2 - } else { - base, i = 8, 1 - } - } - } - - // convert string - assert(2 <= base && base <= 16) - x := Nat(0) - for ; i < n; i++ { - d := hexvalue(s[i]) - if d < base { - x = muladd1(x, digit(base), digit(d)) - } else { - break - } - } - - return x, base, i -} - - -// Natural number functions - -func pop1(x digit) uint { - n := uint(0) - for x != 0 { - x &= x - 1 - n++ - } - return n -} - - -// Pop computes the ``population count'' of (the number of 1 bits in) x. -// -func (x Natural) Pop() uint { - n := uint(0) - for i := len(x) - 1; i >= 0; i-- { - n += pop1(x[i]) - } - return n -} - - -// Pow computes x to the power of n. -// -func (xp Natural) Pow(n uint) Natural { - z := Nat(1) - x := xp - for n > 0 { - // z * x^n == x^n0 - if n&1 == 1 { - z = z.Mul(x) - } - x, n = x.Mul(x), n/2 - } - return z -} - - -// MulRange computes the product of all the unsigned integers -// in the range [a, b] inclusively. -// -func MulRange(a, b uint) Natural { - switch { - case a > b: - return Nat(1) - case a == b: - return Nat(uint64(a)) - case a+1 == b: - return Nat(uint64(a)).Mul(Nat(uint64(b))) - } - m := (a + b) >> 1 - assert(a <= m && m < b) - return MulRange(a, m).Mul(MulRange(m+1, b)) -} - - -// Fact computes the factorial of n (Fact(n) == MulRange(2, n)). -// -func Fact(n uint) Natural { - // Using MulRange() instead of the basic for-loop - // lead to faster factorial computation. - return MulRange(2, n) -} - - -// Binomial computes the binomial coefficient of (n, k). -// -func Binomial(n, k uint) Natural { return MulRange(n-k+1, n).Div(MulRange(1, k)) } - - -// Gcd computes the gcd of x and y. -// -func (x Natural) Gcd(y Natural) Natural { - // Euclidean algorithm. - a, b := x, y - for !b.IsZero() { - a, b = b, a.Mod(b) - } - return a -} diff --git a/src/pkg/exp/bignum/bignum_test.go b/src/pkg/exp/bignum/bignum_test.go deleted file mode 100644 index 8db93aa96..000000000 --- a/src/pkg/exp/bignum/bignum_test.go +++ /dev/null @@ -1,681 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package bignum - -import ( - "fmt" - "testing" -) - -const ( - sa = "991" - sb = "2432902008176640000" // 20! - sc = "933262154439441526816992388562667004907159682643816214685929" + - "638952175999932299156089414639761565182862536979208272237582" + - "51185210916864000000000000000000000000" // 100! - sp = "170141183460469231731687303715884105727" // prime -) - -func natFromString(s string, base uint, slen *int) Natural { - x, _, len := NatFromString(s, base) - if slen != nil { - *slen = len - } - return x -} - - -func intFromString(s string, base uint, slen *int) *Integer { - x, _, len := IntFromString(s, base) - if slen != nil { - *slen = len - } - return x -} - - -func ratFromString(s string, base uint, slen *int) *Rational { - x, _, len := RatFromString(s, base) - if slen != nil { - *slen = len - } - return x -} - - -var ( - nat_zero = Nat(0) - nat_one = Nat(1) - nat_two = Nat(2) - a = natFromString(sa, 10, nil) - b = natFromString(sb, 10, nil) - c = natFromString(sc, 10, nil) - p = natFromString(sp, 10, nil) - int_zero = Int(0) - int_one = Int(1) - int_two = Int(2) - ip = intFromString(sp, 10, nil) - rat_zero = Rat(0, 1) - rat_half = Rat(1, 2) - rat_one = Rat(1, 1) - rat_two = Rat(2, 1) -) - - -var test_msg string -var tester *testing.T - -func test(n uint, b bool) { - if !b { - tester.Fatalf("TEST failed: %s (%d)", test_msg, n) - } -} - - -func nat_eq(n uint, x, y Natural) { - if x.Cmp(y) != 0 { - tester.Fatalf("TEST failed: %s (%d)\nx = %v\ny = %v", test_msg, n, &x, &y) - } -} - - -func int_eq(n uint, x, y *Integer) { - if x.Cmp(y) != 0 { - tester.Fatalf("TEST failed: %s (%d)\nx = %v\ny = %v", test_msg, n, x, y) - } -} - - -func rat_eq(n uint, x, y *Rational) { - if x.Cmp(y) != 0 { - tester.Fatalf("TEST failed: %s (%d)\nx = %v\ny = %v", test_msg, n, x, y) - } -} - - -func TestNatConv(t *testing.T) { - tester = t - test_msg = "NatConvA" - type entry1 struct { - x uint64 - s string - } - tab := []entry1{ - entry1{0, "0"}, - entry1{255, "255"}, - entry1{65535, "65535"}, - entry1{4294967295, "4294967295"}, - entry1{18446744073709551615, "18446744073709551615"}, - } - for i, e := range tab { - test(100+uint(i), Nat(e.x).String() == e.s) - test(200+uint(i), natFromString(e.s, 0, nil).Value() == e.x) - } - - test_msg = "NatConvB" - for i := uint(0); i < 100; i++ { - test(i, Nat(uint64(i)).String() == fmt.Sprintf("%d", i)) - } - - test_msg = "NatConvC" - z := uint64(7) - for i := uint(0); i <= 64; i++ { - test(i, Nat(z).Value() == z) - z <<= 1 - } - - test_msg = "NatConvD" - nat_eq(0, a, Nat(991)) - nat_eq(1, b, Fact(20)) - nat_eq(2, c, Fact(100)) - test(3, a.String() == sa) - test(4, b.String() == sb) - test(5, c.String() == sc) - - test_msg = "NatConvE" - var slen int - nat_eq(10, natFromString("0", 0, nil), nat_zero) - nat_eq(11, natFromString("123", 0, nil), Nat(123)) - nat_eq(12, natFromString("077", 0, nil), Nat(7*8+7)) - nat_eq(13, natFromString("0x1f", 0, nil), Nat(1*16+15)) - nat_eq(14, natFromString("0x1fg", 0, &slen), Nat(1*16+15)) - test(4, slen == 4) - - test_msg = "NatConvF" - tmp := c.Mul(c) - for base := uint(2); base <= 16; base++ { - nat_eq(base, natFromString(tmp.ToString(base), base, nil), tmp) - } - - test_msg = "NatConvG" - x := Nat(100) - y, _, _ := NatFromString(fmt.Sprintf("%b", &x), 2) - nat_eq(100, y, x) -} - - -func abs(x int64) uint64 { - if x < 0 { - x = -x - } - return uint64(x) -} - - -func TestIntConv(t *testing.T) { - tester = t - test_msg = "IntConvA" - type entry2 struct { - x int64 - s string - } - tab := []entry2{ - entry2{0, "0"}, - entry2{-128, "-128"}, - entry2{127, "127"}, - entry2{-32768, "-32768"}, - entry2{32767, "32767"}, - entry2{-2147483648, "-2147483648"}, - entry2{2147483647, "2147483647"}, - entry2{-9223372036854775808, "-9223372036854775808"}, - entry2{9223372036854775807, "9223372036854775807"}, - } - for i, e := range tab { - test(100+uint(i), Int(e.x).String() == e.s) - test(200+uint(i), intFromString(e.s, 0, nil).Value() == e.x) - test(300+uint(i), Int(e.x).Abs().Value() == abs(e.x)) - } - - test_msg = "IntConvB" - var slen int - int_eq(0, intFromString("0", 0, nil), int_zero) - int_eq(1, intFromString("-0", 0, nil), int_zero) - int_eq(2, intFromString("123", 0, nil), Int(123)) - int_eq(3, intFromString("-123", 0, nil), Int(-123)) - int_eq(4, intFromString("077", 0, nil), Int(7*8+7)) - int_eq(5, intFromString("-077", 0, nil), Int(-(7*8 + 7))) - int_eq(6, intFromString("0x1f", 0, nil), Int(1*16+15)) - int_eq(7, intFromString("-0x1f", 0, &slen), Int(-(1*16 + 15))) - test(7, slen == 5) - int_eq(8, intFromString("+0x1f", 0, &slen), Int(+(1*16 + 15))) - test(8, slen == 5) - int_eq(9, intFromString("0x1fg", 0, &slen), Int(1*16+15)) - test(9, slen == 4) - int_eq(10, intFromString("-0x1fg", 0, &slen), Int(-(1*16 + 15))) - test(10, slen == 5) -} - - -func TestRatConv(t *testing.T) { - tester = t - test_msg = "RatConv" - var slen int - rat_eq(0, ratFromString("0", 0, nil), rat_zero) - rat_eq(1, ratFromString("0/1", 0, nil), rat_zero) - rat_eq(2, ratFromString("0/01", 0, nil), rat_zero) - rat_eq(3, ratFromString("0x14/10", 0, &slen), rat_two) - test(4, slen == 7) - rat_eq(5, ratFromString("0.", 0, nil), rat_zero) - rat_eq(6, ratFromString("0.001f", 10, nil), Rat(1, 1000)) - rat_eq(7, ratFromString(".1", 0, nil), Rat(1, 10)) - rat_eq(8, ratFromString("10101.0101", 2, nil), Rat(0x155, 1<<4)) - rat_eq(9, ratFromString("-0003.145926", 10, &slen), Rat(-3145926, 1000000)) - test(10, slen == 12) - rat_eq(11, ratFromString("1e2", 0, nil), Rat(100, 1)) - rat_eq(12, ratFromString("1e-2", 0, nil), Rat(1, 100)) - rat_eq(13, ratFromString("1.1e2", 0, nil), Rat(110, 1)) - rat_eq(14, ratFromString(".1e2x", 0, &slen), Rat(10, 1)) - test(15, slen == 4) -} - - -func add(x, y Natural) Natural { - z1 := x.Add(y) - z2 := y.Add(x) - if z1.Cmp(z2) != 0 { - tester.Fatalf("addition not symmetric:\n\tx = %v\n\ty = %t", x, y) - } - return z1 -} - - -func sum(n uint64, scale Natural) Natural { - s := nat_zero - for ; n > 0; n-- { - s = add(s, Nat(n).Mul(scale)) - } - return s -} - - -func TestNatAdd(t *testing.T) { - tester = t - test_msg = "NatAddA" - nat_eq(0, add(nat_zero, nat_zero), nat_zero) - nat_eq(1, add(nat_zero, c), c) - - test_msg = "NatAddB" - for i := uint64(0); i < 100; i++ { - t := Nat(i) - nat_eq(uint(i), sum(i, c), t.Mul(t).Add(t).Shr(1).Mul(c)) - } -} - - -func mul(x, y Natural) Natural { - z1 := x.Mul(y) - z2 := y.Mul(x) - if z1.Cmp(z2) != 0 { - tester.Fatalf("multiplication not symmetric:\n\tx = %v\n\ty = %t", x, y) - } - if !x.IsZero() && z1.Div(x).Cmp(y) != 0 { - tester.Fatalf("multiplication/division not inverse (A):\n\tx = %v\n\ty = %t", x, y) - } - if !y.IsZero() && z1.Div(y).Cmp(x) != 0 { - tester.Fatalf("multiplication/division not inverse (B):\n\tx = %v\n\ty = %t", x, y) - } - return z1 -} - - -func TestNatSub(t *testing.T) { - tester = t - test_msg = "NatSubA" - nat_eq(0, nat_zero.Sub(nat_zero), nat_zero) - nat_eq(1, c.Sub(nat_zero), c) - - test_msg = "NatSubB" - for i := uint64(0); i < 100; i++ { - t := sum(i, c) - for j := uint64(0); j <= i; j++ { - t = t.Sub(mul(Nat(j), c)) - } - nat_eq(uint(i), t, nat_zero) - } -} - - -func TestNatMul(t *testing.T) { - tester = t - test_msg = "NatMulA" - nat_eq(0, mul(c, nat_zero), nat_zero) - nat_eq(1, mul(c, nat_one), c) - - test_msg = "NatMulB" - nat_eq(0, b.Mul(MulRange(0, 100)), nat_zero) - nat_eq(1, b.Mul(MulRange(21, 100)), c) - - test_msg = "NatMulC" - const n = 100 - p := b.Mul(c).Shl(n) - for i := uint(0); i < n; i++ { - nat_eq(i, mul(b.Shl(i), c.Shl(n-i)), p) - } -} - - -func TestNatDiv(t *testing.T) { - tester = t - test_msg = "NatDivA" - nat_eq(0, c.Div(nat_one), c) - nat_eq(1, c.Div(Nat(100)), Fact(99)) - nat_eq(2, b.Div(c), nat_zero) - nat_eq(4, nat_one.Shl(100).Div(nat_one.Shl(90)), nat_one.Shl(10)) - nat_eq(5, c.Div(b), MulRange(21, 100)) - - test_msg = "NatDivB" - const n = 100 - p := Fact(n) - for i := uint(0); i < n; i++ { - nat_eq(100+i, p.Div(MulRange(1, i)), MulRange(i+1, n)) - } - - // a specific test case that exposed a bug in package big - test_msg = "NatDivC" - x := natFromString("69720375229712477164533808935312303556800", 10, nil) - y := natFromString("3099044504245996706400", 10, nil) - q := natFromString("22497377864108980962", 10, nil) - r := natFromString("0", 10, nil) - qc, rc := x.DivMod(y) - nat_eq(0, q, qc) - nat_eq(1, r, rc) -} - - -func TestIntQuoRem(t *testing.T) { - tester = t - test_msg = "IntQuoRem" - type T struct { - x, y, q, r int64 - } - a := []T{ - T{+8, +3, +2, +2}, - T{+8, -3, -2, +2}, - T{-8, +3, -2, -2}, - T{-8, -3, +2, -2}, - T{+1, +2, 0, +1}, - T{+1, -2, 0, +1}, - T{-1, +2, 0, -1}, - T{-1, -2, 0, -1}, - } - for i := uint(0); i < uint(len(a)); i++ { - e := &a[i] - x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip) - q, r := Int(e.q), Int(e.r).Mul(ip) - qq, rr := x.QuoRem(y) - int_eq(4*i+0, x.Quo(y), q) - int_eq(4*i+1, x.Rem(y), r) - int_eq(4*i+2, qq, q) - int_eq(4*i+3, rr, r) - } -} - - -func TestIntDivMod(t *testing.T) { - tester = t - test_msg = "IntDivMod" - type T struct { - x, y, q, r int64 - } - a := []T{ - T{+8, +3, +2, +2}, - T{+8, -3, -2, +2}, - T{-8, +3, -3, +1}, - T{-8, -3, +3, +1}, - T{+1, +2, 0, +1}, - T{+1, -2, 0, +1}, - T{-1, +2, -1, +1}, - T{-1, -2, +1, +1}, - } - for i := uint(0); i < uint(len(a)); i++ { - e := &a[i] - x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip) - q, r := Int(e.q), Int(e.r).Mul(ip) - qq, rr := x.DivMod(y) - int_eq(4*i+0, x.Div(y), q) - int_eq(4*i+1, x.Mod(y), r) - int_eq(4*i+2, qq, q) - int_eq(4*i+3, rr, r) - } -} - - -func TestNatMod(t *testing.T) { - tester = t - test_msg = "NatModA" - for i := uint(0); ; i++ { - d := nat_one.Shl(i) - if d.Cmp(c) < 0 { - nat_eq(i, c.Add(d).Mod(c), d) - } else { - nat_eq(i, c.Add(d).Div(c), nat_two) - nat_eq(i, c.Add(d).Mod(c), d.Sub(c)) - break - } - } -} - - -func TestNatShift(t *testing.T) { - tester = t - test_msg = "NatShift1L" - test(0, b.Shl(0).Cmp(b) == 0) - test(1, c.Shl(1).Cmp(c) > 0) - - test_msg = "NatShift1R" - test(3, b.Shr(0).Cmp(b) == 0) - test(4, c.Shr(1).Cmp(c) < 0) - - test_msg = "NatShift2" - for i := uint(0); i < 100; i++ { - test(i, c.Shl(i).Shr(i).Cmp(c) == 0) - } - - test_msg = "NatShift3L" - { - const m = 3 - p := b - f := Nat(1 << m) - for i := uint(0); i < 100; i++ { - nat_eq(i, b.Shl(i*m), p) - p = mul(p, f) - } - } - - test_msg = "NatShift3R" - { - p := c - for i := uint(0); !p.IsZero(); i++ { - nat_eq(i, c.Shr(i), p) - p = p.Shr(1) - } - } -} - - -func TestIntShift(t *testing.T) { - tester = t - test_msg = "IntShift1L" - test(0, ip.Shl(0).Cmp(ip) == 0) - test(1, ip.Shl(1).Cmp(ip) > 0) - - test_msg = "IntShift1R" - test(0, ip.Shr(0).Cmp(ip) == 0) - test(1, ip.Shr(1).Cmp(ip) < 0) - - test_msg = "IntShift2" - for i := uint(0); i < 100; i++ { - test(i, ip.Shl(i).Shr(i).Cmp(ip) == 0) - } - - test_msg = "IntShift3L" - { - const m = 3 - p := ip - f := Int(1 << m) - for i := uint(0); i < 100; i++ { - int_eq(i, ip.Shl(i*m), p) - p = p.Mul(f) - } - } - - test_msg = "IntShift3R" - { - p := ip - for i := uint(0); p.IsPos(); i++ { - int_eq(i, ip.Shr(i), p) - p = p.Shr(1) - } - } - - test_msg = "IntShift4R" - int_eq(0, Int(-43).Shr(1), Int(-43>>1)) - int_eq(0, Int(-1024).Shr(100), Int(-1)) - int_eq(1, ip.Neg().Shr(10), ip.Neg().Div(Int(1).Shl(10))) -} - - -func TestNatBitOps(t *testing.T) { - tester = t - - x := uint64(0xf08e6f56bd8c3941) - y := uint64(0x3984ef67834bc) - - bx := Nat(x) - by := Nat(y) - - test_msg = "NatAnd" - bz := Nat(x & y) - for i := uint(0); i < 100; i++ { - nat_eq(i, bx.Shl(i).And(by.Shl(i)), bz.Shl(i)) - } - - test_msg = "NatAndNot" - bz = Nat(x &^ y) - for i := uint(0); i < 100; i++ { - nat_eq(i, bx.Shl(i).AndNot(by.Shl(i)), bz.Shl(i)) - } - - test_msg = "NatOr" - bz = Nat(x | y) - for i := uint(0); i < 100; i++ { - nat_eq(i, bx.Shl(i).Or(by.Shl(i)), bz.Shl(i)) - } - - test_msg = "NatXor" - bz = Nat(x ^ y) - for i := uint(0); i < 100; i++ { - nat_eq(i, bx.Shl(i).Xor(by.Shl(i)), bz.Shl(i)) - } -} - - -func TestIntBitOps1(t *testing.T) { - tester = t - test_msg = "IntBitOps1" - type T struct { - x, y int64 - } - a := []T{ - T{+7, +3}, - T{+7, -3}, - T{-7, +3}, - T{-7, -3}, - } - for i := uint(0); i < uint(len(a)); i++ { - e := &a[i] - int_eq(4*i+0, Int(e.x).And(Int(e.y)), Int(e.x&e.y)) - int_eq(4*i+1, Int(e.x).AndNot(Int(e.y)), Int(e.x&^e.y)) - int_eq(4*i+2, Int(e.x).Or(Int(e.y)), Int(e.x|e.y)) - int_eq(4*i+3, Int(e.x).Xor(Int(e.y)), Int(e.x^e.y)) - } -} - - -func TestIntBitOps2(t *testing.T) { - tester = t - - test_msg = "IntNot" - int_eq(0, Int(-2).Not(), Int(1)) - int_eq(0, Int(-1).Not(), Int(0)) - int_eq(0, Int(0).Not(), Int(-1)) - int_eq(0, Int(1).Not(), Int(-2)) - int_eq(0, Int(2).Not(), Int(-3)) - - test_msg = "IntAnd" - for x := int64(-15); x < 5; x++ { - bx := Int(x) - for y := int64(-5); y < 15; y++ { - by := Int(y) - for i := uint(50); i < 70; i++ { // shift across 64bit boundary - int_eq(i, bx.Shl(i).And(by.Shl(i)), Int(x&y).Shl(i)) - } - } - } - - test_msg = "IntAndNot" - for x := int64(-15); x < 5; x++ { - bx := Int(x) - for y := int64(-5); y < 15; y++ { - by := Int(y) - for i := uint(50); i < 70; i++ { // shift across 64bit boundary - int_eq(2*i+0, bx.Shl(i).AndNot(by.Shl(i)), Int(x&^y).Shl(i)) - int_eq(2*i+1, bx.Shl(i).And(by.Shl(i).Not()), Int(x&^y).Shl(i)) - } - } - } - - test_msg = "IntOr" - for x := int64(-15); x < 5; x++ { - bx := Int(x) - for y := int64(-5); y < 15; y++ { - by := Int(y) - for i := uint(50); i < 70; i++ { // shift across 64bit boundary - int_eq(i, bx.Shl(i).Or(by.Shl(i)), Int(x|y).Shl(i)) - } - } - } - - test_msg = "IntXor" - for x := int64(-15); x < 5; x++ { - bx := Int(x) - for y := int64(-5); y < 15; y++ { - by := Int(y) - for i := uint(50); i < 70; i++ { // shift across 64bit boundary - int_eq(i, bx.Shl(i).Xor(by.Shl(i)), Int(x^y).Shl(i)) - } - } - } -} - - -func TestNatCmp(t *testing.T) { - tester = t - test_msg = "NatCmp" - test(0, a.Cmp(a) == 0) - test(1, a.Cmp(b) < 0) - test(2, b.Cmp(a) > 0) - test(3, a.Cmp(c) < 0) - d := c.Add(b) - test(4, c.Cmp(d) < 0) - test(5, d.Cmp(c) > 0) -} - - -func TestNatLog2(t *testing.T) { - tester = t - test_msg = "NatLog2A" - test(0, nat_one.Log2() == 0) - test(1, nat_two.Log2() == 1) - test(2, Nat(3).Log2() == 1) - test(3, Nat(4).Log2() == 2) - - test_msg = "NatLog2B" - for i := uint(0); i < 100; i++ { - test(i, nat_one.Shl(i).Log2() == i) - } -} - - -func TestNatGcd(t *testing.T) { - tester = t - test_msg = "NatGcdA" - f := Nat(99991) - nat_eq(0, b.Mul(f).Gcd(c.Mul(f)), MulRange(1, 20).Mul(f)) -} - - -func TestNatPow(t *testing.T) { - tester = t - test_msg = "NatPowA" - nat_eq(0, nat_two.Pow(0), nat_one) - - test_msg = "NatPowB" - for i := uint(0); i < 100; i++ { - nat_eq(i, nat_two.Pow(i), nat_one.Shl(i)) - } -} - - -func TestNatPop(t *testing.T) { - tester = t - test_msg = "NatPopA" - test(0, nat_zero.Pop() == 0) - test(1, nat_one.Pop() == 1) - test(2, Nat(10).Pop() == 2) - test(3, Nat(30).Pop() == 4) - test(4, Nat(0x1248f).Shl(33).Pop() == 8) - - test_msg = "NatPopB" - for i := uint(0); i < 100; i++ { - test(i, nat_one.Shl(i).Sub(nat_one).Pop() == i) - } -} - - -func TestIssue571(t *testing.T) { - const min_float = "4.940656458412465441765687928682213723651e-324" - RatFromString(min_float, 10) // this must not crash -} diff --git a/src/pkg/exp/bignum/integer.go b/src/pkg/exp/bignum/integer.go deleted file mode 100644 index a8d26829d..000000000 --- a/src/pkg/exp/bignum/integer.go +++ /dev/null @@ -1,520 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Integer numbers -// -// Integers are normalized if the mantissa is normalized and the sign is -// false for mant == 0. Use MakeInt to create normalized Integers. - -package bignum - -import ( - "fmt" -) - -// TODO(gri) Complete the set of in-place operations. - -// Integer represents a signed integer value of arbitrary precision. -// -type Integer struct { - sign bool - mant Natural -} - - -// MakeInt makes an integer given a sign and a mantissa. -// The number is positive (>= 0) if sign is false or the -// mantissa is zero; it is negative otherwise. -// -func MakeInt(sign bool, mant Natural) *Integer { - if mant.IsZero() { - sign = false // normalize - } - return &Integer{sign, mant} -} - - -// Int creates a small integer with value x. -// -func Int(x int64) *Integer { - var ux uint64 - if x < 0 { - // For the most negative x, -x == x, and - // the bit pattern has the correct value. - ux = uint64(-x) - } else { - ux = uint64(x) - } - return MakeInt(x < 0, Nat(ux)) -} - - -// Value returns the value of x, if x fits into an int64; -// otherwise the result is undefined. -// -func (x *Integer) Value() int64 { - z := int64(x.mant.Value()) - if x.sign { - z = -z - } - return z -} - - -// Abs returns the absolute value of x. -// -func (x *Integer) Abs() Natural { return x.mant } - - -// Predicates - -// IsEven returns true iff x is divisible by 2. -// -func (x *Integer) IsEven() bool { return x.mant.IsEven() } - - -// IsOdd returns true iff x is not divisible by 2. -// -func (x *Integer) IsOdd() bool { return x.mant.IsOdd() } - - -// IsZero returns true iff x == 0. -// -func (x *Integer) IsZero() bool { return x.mant.IsZero() } - - -// IsNeg returns true iff x < 0. -// -func (x *Integer) IsNeg() bool { return x.sign && !x.mant.IsZero() } - - -// IsPos returns true iff x >= 0. -// -func (x *Integer) IsPos() bool { return !x.sign && !x.mant.IsZero() } - - -// Operations - -// Neg returns the negated value of x. -// -func (x *Integer) Neg() *Integer { return MakeInt(!x.sign, x.mant) } - - -// Iadd sets z to the sum x + y. -// z must exist and may be x or y. -// -func Iadd(z, x, y *Integer) { - if x.sign == y.sign { - // x + y == x + y - // (-x) + (-y) == -(x + y) - z.sign = x.sign - Nadd(&z.mant, x.mant, y.mant) - } else { - // x + (-y) == x - y == -(y - x) - // (-x) + y == y - x == -(x - y) - if x.mant.Cmp(y.mant) >= 0 { - z.sign = x.sign - Nsub(&z.mant, x.mant, y.mant) - } else { - z.sign = !x.sign - Nsub(&z.mant, y.mant, x.mant) - } - } -} - - -// Add returns the sum x + y. -// -func (x *Integer) Add(y *Integer) *Integer { - var z Integer - Iadd(&z, x, y) - return &z -} - - -func Isub(z, x, y *Integer) { - if x.sign != y.sign { - // x - (-y) == x + y - // (-x) - y == -(x + y) - z.sign = x.sign - Nadd(&z.mant, x.mant, y.mant) - } else { - // x - y == x - y == -(y - x) - // (-x) - (-y) == y - x == -(x - y) - if x.mant.Cmp(y.mant) >= 0 { - z.sign = x.sign - Nsub(&z.mant, x.mant, y.mant) - } else { - z.sign = !x.sign - Nsub(&z.mant, y.mant, x.mant) - } - } -} - - -// Sub returns the difference x - y. -// -func (x *Integer) Sub(y *Integer) *Integer { - var z Integer - Isub(&z, x, y) - return &z -} - - -// Nscale sets *z to the scaled value (*z) * d. -// -func Iscale(z *Integer, d int64) { - f := uint64(d) - if d < 0 { - f = uint64(-d) - } - z.sign = z.sign != (d < 0) - Nscale(&z.mant, f) -} - - -// Mul1 returns the product x * d. -// -func (x *Integer) Mul1(d int64) *Integer { - f := uint64(d) - if d < 0 { - f = uint64(-d) - } - return MakeInt(x.sign != (d < 0), x.mant.Mul1(f)) -} - - -// Mul returns the product x * y. -// -func (x *Integer) Mul(y *Integer) *Integer { - // x * y == x * y - // x * (-y) == -(x * y) - // (-x) * y == -(x * y) - // (-x) * (-y) == x * y - return MakeInt(x.sign != y.sign, x.mant.Mul(y.mant)) -} - - -// MulNat returns the product x * y, where y is a (unsigned) natural number. -// -func (x *Integer) MulNat(y Natural) *Integer { - // x * y == x * y - // (-x) * y == -(x * y) - return MakeInt(x.sign, x.mant.Mul(y)) -} - - -// Quo returns the quotient q = x / y for y != 0. -// If y == 0, a division-by-zero run-time error occurs. -// -// Quo and Rem implement T-division and modulus (like C99): -// -// q = x.Quo(y) = trunc(x/y) (truncation towards zero) -// r = x.Rem(y) = x - y*q -// -// (Daan Leijen, ``Division and Modulus for Computer Scientists''.) -// -func (x *Integer) Quo(y *Integer) *Integer { - // x / y == x / y - // x / (-y) == -(x / y) - // (-x) / y == -(x / y) - // (-x) / (-y) == x / y - return MakeInt(x.sign != y.sign, x.mant.Div(y.mant)) -} - - -// Rem returns the remainder r of the division x / y for y != 0, -// with r = x - y*x.Quo(y). Unless r is zero, its sign corresponds -// to the sign of x. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x *Integer) Rem(y *Integer) *Integer { - // x % y == x % y - // x % (-y) == x % y - // (-x) % y == -(x % y) - // (-x) % (-y) == -(x % y) - return MakeInt(x.sign, x.mant.Mod(y.mant)) -} - - -// QuoRem returns the pair (x.Quo(y), x.Rem(y)) for y != 0. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x *Integer) QuoRem(y *Integer) (*Integer, *Integer) { - q, r := x.mant.DivMod(y.mant) - return MakeInt(x.sign != y.sign, q), MakeInt(x.sign, r) -} - - -// Div returns the quotient q = x / y for y != 0. -// If y == 0, a division-by-zero run-time error occurs. -// -// Div and Mod implement Euclidian division and modulus: -// -// q = x.Div(y) -// r = x.Mod(y) with: 0 <= r < |q| and: x = y*q + r -// -// (Raymond T. Boute, ``The Euclidian definition of the functions -// div and mod''. ACM Transactions on Programming Languages and -// Systems (TOPLAS), 14(2):127-144, New York, NY, USA, 4/1992. -// ACM press.) -// -func (x *Integer) Div(y *Integer) *Integer { - q, r := x.QuoRem(y) - if r.IsNeg() { - if y.IsPos() { - q = q.Sub(Int(1)) - } else { - q = q.Add(Int(1)) - } - } - return q -} - - -// Mod returns the modulus r of the division x / y for y != 0, -// with r = x - y*x.Div(y). r is always positive. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x *Integer) Mod(y *Integer) *Integer { - r := x.Rem(y) - if r.IsNeg() { - if y.IsPos() { - r = r.Add(y) - } else { - r = r.Sub(y) - } - } - return r -} - - -// DivMod returns the pair (x.Div(y), x.Mod(y)). -// -func (x *Integer) DivMod(y *Integer) (*Integer, *Integer) { - q, r := x.QuoRem(y) - if r.IsNeg() { - if y.IsPos() { - q = q.Sub(Int(1)) - r = r.Add(y) - } else { - q = q.Add(Int(1)) - r = r.Sub(y) - } - } - return q, r -} - - -// Shl implements ``shift left'' x << s. It returns x * 2^s. -// -func (x *Integer) Shl(s uint) *Integer { return MakeInt(x.sign, x.mant.Shl(s)) } - - -// The bitwise operations on integers are defined on the 2's-complement -// representation of integers. From -// -// -x == ^x + 1 (1) 2's complement representation -// -// follows: -// -// -(x) == ^(x) + 1 -// -(-x) == ^(-x) + 1 -// x-1 == ^(-x) -// ^(x-1) == -x (2) -// -// Using (1) and (2), operations on negative integers of the form -x are -// converted to operations on negated positive integers of the form ~(x-1). - - -// Shr implements ``shift right'' x >> s. It returns x / 2^s. -// -func (x *Integer) Shr(s uint) *Integer { - if x.sign { - // (-x) >> s == ^(x-1) >> s == ^((x-1) >> s) == -(((x-1) >> s) + 1) - return MakeInt(true, x.mant.Sub(Nat(1)).Shr(s).Add(Nat(1))) - } - - return MakeInt(false, x.mant.Shr(s)) -} - - -// Not returns the ``bitwise not'' ^x for the 2's-complement representation of x. -func (x *Integer) Not() *Integer { - if x.sign { - // ^(-x) == ^(^(x-1)) == x-1 - return MakeInt(false, x.mant.Sub(Nat(1))) - } - - // ^x == -x-1 == -(x+1) - return MakeInt(true, x.mant.Add(Nat(1))) -} - - -// And returns the ``bitwise and'' x & y for the 2's-complement representation of x and y. -// -func (x *Integer) And(y *Integer) *Integer { - if x.sign == y.sign { - if x.sign { - // (-x) & (-y) == ^(x-1) & ^(y-1) == ^((x-1) | (y-1)) == -(((x-1) | (y-1)) + 1) - return MakeInt(true, x.mant.Sub(Nat(1)).Or(y.mant.Sub(Nat(1))).Add(Nat(1))) - } - - // x & y == x & y - return MakeInt(false, x.mant.And(y.mant)) - } - - // x.sign != y.sign - if x.sign { - x, y = y, x // & is symmetric - } - - // x & (-y) == x & ^(y-1) == x &^ (y-1) - return MakeInt(false, x.mant.AndNot(y.mant.Sub(Nat(1)))) -} - - -// AndNot returns the ``bitwise clear'' x &^ y for the 2's-complement representation of x and y. -// -func (x *Integer) AndNot(y *Integer) *Integer { - if x.sign == y.sign { - if x.sign { - // (-x) &^ (-y) == ^(x-1) &^ ^(y-1) == ^(x-1) & (y-1) == (y-1) &^ (x-1) - return MakeInt(false, y.mant.Sub(Nat(1)).AndNot(x.mant.Sub(Nat(1)))) - } - - // x &^ y == x &^ y - return MakeInt(false, x.mant.AndNot(y.mant)) - } - - if x.sign { - // (-x) &^ y == ^(x-1) &^ y == ^(x-1) & ^y == ^((x-1) | y) == -(((x-1) | y) + 1) - return MakeInt(true, x.mant.Sub(Nat(1)).Or(y.mant).Add(Nat(1))) - } - - // x &^ (-y) == x &^ ^(y-1) == x & (y-1) - return MakeInt(false, x.mant.And(y.mant.Sub(Nat(1)))) -} - - -// Or returns the ``bitwise or'' x | y for the 2's-complement representation of x and y. -// -func (x *Integer) Or(y *Integer) *Integer { - if x.sign == y.sign { - if x.sign { - // (-x) | (-y) == ^(x-1) | ^(y-1) == ^((x-1) & (y-1)) == -(((x-1) & (y-1)) + 1) - return MakeInt(true, x.mant.Sub(Nat(1)).And(y.mant.Sub(Nat(1))).Add(Nat(1))) - } - - // x | y == x | y - return MakeInt(false, x.mant.Or(y.mant)) - } - - // x.sign != y.sign - if x.sign { - x, y = y, x // | or symmetric - } - - // x | (-y) == x | ^(y-1) == ^((y-1) &^ x) == -(^((y-1) &^ x) + 1) - return MakeInt(true, y.mant.Sub(Nat(1)).AndNot(x.mant).Add(Nat(1))) -} - - -// Xor returns the ``bitwise xor'' x | y for the 2's-complement representation of x and y. -// -func (x *Integer) Xor(y *Integer) *Integer { - if x.sign == y.sign { - if x.sign { - // (-x) ^ (-y) == ^(x-1) ^ ^(y-1) == (x-1) ^ (y-1) - return MakeInt(false, x.mant.Sub(Nat(1)).Xor(y.mant.Sub(Nat(1)))) - } - - // x ^ y == x ^ y - return MakeInt(false, x.mant.Xor(y.mant)) - } - - // x.sign != y.sign - if x.sign { - x, y = y, x // ^ is symmetric - } - - // x ^ (-y) == x ^ ^(y-1) == ^(x ^ (y-1)) == -((x ^ (y-1)) + 1) - return MakeInt(true, x.mant.Xor(y.mant.Sub(Nat(1))).Add(Nat(1))) -} - - -// Cmp compares x and y. The result is an int value that is -// -// < 0 if x < y -// == 0 if x == y -// > 0 if x > y -// -func (x *Integer) Cmp(y *Integer) int { - // x cmp y == x cmp y - // x cmp (-y) == x - // (-x) cmp y == y - // (-x) cmp (-y) == -(x cmp y) - var r int - switch { - case x.sign == y.sign: - r = x.mant.Cmp(y.mant) - if x.sign { - r = -r - } - case x.sign: - r = -1 - case y.sign: - r = 1 - } - return r -} - - -// ToString converts x to a string for a given base, with 2 <= base <= 16. -// -func (x *Integer) ToString(base uint) string { - if x.mant.IsZero() { - return "0" - } - var s string - if x.sign { - s = "-" - } - return s + x.mant.ToString(base) -} - - -// String converts x to its decimal string representation. -// x.String() is the same as x.ToString(10). -// -func (x *Integer) String() string { return x.ToString(10) } - - -// Format is a support routine for fmt.Formatter. It accepts -// the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). -// -func (x *Integer) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } - - -// IntFromString returns the integer corresponding to the -// longest possible prefix of s representing an integer in a -// given conversion base, the actual conversion base used, and -// the prefix length. The syntax of integers follows the syntax -// of signed integer literals in Go. -// -// If the base argument is 0, the string prefix determines the actual -// conversion base. A prefix of ``0x'' or ``0X'' selects base 16; the -// ``0'' prefix selects base 8. Otherwise the selected base is 10. -// -func IntFromString(s string, base uint) (*Integer, uint, int) { - // skip sign, if any - i0 := 0 - if len(s) > 0 && (s[0] == '-' || s[0] == '+') { - i0 = 1 - } - - mant, base, slen := NatFromString(s[i0:], base) - - return MakeInt(i0 > 0 && s[0] == '-', mant), base, i0 + slen -} diff --git a/src/pkg/exp/bignum/nrdiv_test.go b/src/pkg/exp/bignum/nrdiv_test.go deleted file mode 100644 index 725b1acea..000000000 --- a/src/pkg/exp/bignum/nrdiv_test.go +++ /dev/null @@ -1,188 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file implements Newton-Raphson division and uses -// it as an additional test case for bignum. -// -// Division of x/y is achieved by computing r = 1/y to -// obtain the quotient q = x*r = x*(1/y) = x/y. The -// reciprocal r is the solution for f(x) = 1/x - y and -// the solution is approximated through iteration. The -// iteration does not require division. - -package bignum - -import "testing" - - -// An fpNat is a Natural scaled by a power of two -// (an unsigned floating point representation). The -// value of an fpNat x is x.m * 2^x.e . -// -type fpNat struct { - m Natural - e int -} - - -// sub computes x - y. -func (x fpNat) sub(y fpNat) fpNat { - switch d := x.e - y.e; { - case d < 0: - return fpNat{x.m.Sub(y.m.Shl(uint(-d))), x.e} - case d > 0: - return fpNat{x.m.Shl(uint(d)).Sub(y.m), y.e} - } - return fpNat{x.m.Sub(y.m), x.e} -} - - -// mul2 computes x*2. -func (x fpNat) mul2() fpNat { return fpNat{x.m, x.e + 1} } - - -// mul computes x*y. -func (x fpNat) mul(y fpNat) fpNat { return fpNat{x.m.Mul(y.m), x.e + y.e} } - - -// mant computes the (possibly truncated) Natural representation -// of an fpNat x. -// -func (x fpNat) mant() Natural { - switch { - case x.e > 0: - return x.m.Shl(uint(x.e)) - case x.e < 0: - return x.m.Shr(uint(-x.e)) - } - return x.m -} - - -// nrDivEst computes an estimate of the quotient q = x0/y0 and returns q. -// q may be too small (usually by 1). -// -func nrDivEst(x0, y0 Natural) Natural { - if y0.IsZero() { - panic("division by zero") - return nil - } - // y0 > 0 - - if y0.Cmp(Nat(1)) == 0 { - return x0 - } - // y0 > 1 - - switch d := x0.Cmp(y0); { - case d < 0: - return Nat(0) - case d == 0: - return Nat(1) - } - // x0 > y0 > 1 - - // Determine maximum result length. - maxLen := int(x0.Log2() - y0.Log2() + 1) - - // In the following, each number x is represented - // as a mantissa x.m and an exponent x.e such that - // x = xm * 2^x.e. - x := fpNat{x0, 0} - y := fpNat{y0, 0} - - // Determine a scale factor f = 2^e such that - // 0.5 <= y/f == y*(2^-e) < 1.0 - // and scale y accordingly. - e := int(y.m.Log2()) + 1 - y.e -= e - - // t1 - var c = 2.9142 - const n = 14 - t1 := fpNat{Nat(uint64(c * (1 << n))), -n} - - // Compute initial value r0 for the reciprocal of y/f. - // r0 = t1 - 2*y - r := t1.sub(y.mul2()) - two := fpNat{Nat(2), 0} - - // Newton-Raphson iteration - p := Nat(0) - for i := 0; ; i++ { - // check if we are done - // TODO: Need to come up with a better test here - // as it will reduce computation time significantly. - // q = x*r/f - q := x.mul(r) - q.e -= e - res := q.mant() - if res.Cmp(p) == 0 { - return res - } - p = res - - // r' = r*(2 - y*r) - r = r.mul(two.sub(y.mul(r))) - - // reduce mantissa size - // TODO: Find smaller bound as it will reduce - // computation time massively. - d := int(r.m.Log2()+1) - maxLen - if d > 0 { - r = fpNat{r.m.Shr(uint(d)), r.e + d} - } - } - - panic("unreachable") - return nil -} - - -func nrdiv(x, y Natural) (q, r Natural) { - q = nrDivEst(x, y) - r = x.Sub(y.Mul(q)) - // if r is too large, correct q and r - // (usually one iteration) - for r.Cmp(y) >= 0 { - q = q.Add(Nat(1)) - r = r.Sub(y) - } - return -} - - -func div(t *testing.T, x, y Natural) { - q, r := nrdiv(x, y) - qx, rx := x.DivMod(y) - if q.Cmp(qx) != 0 { - t.Errorf("x = %s, y = %s, got q = %s, want q = %s", x, y, q, qx) - } - if r.Cmp(rx) != 0 { - t.Errorf("x = %s, y = %s, got r = %s, want r = %s", x, y, r, rx) - } -} - - -func idiv(t *testing.T, x0, y0 uint64) { div(t, Nat(x0), Nat(y0)) } - - -func TestNRDiv(t *testing.T) { - idiv(t, 17, 18) - idiv(t, 17, 17) - idiv(t, 17, 1) - idiv(t, 17, 16) - idiv(t, 17, 10) - idiv(t, 17, 9) - idiv(t, 17, 8) - idiv(t, 17, 5) - idiv(t, 17, 3) - idiv(t, 1025, 512) - idiv(t, 7489595, 2) - idiv(t, 5404679459, 78495) - idiv(t, 7484890589595, 7484890589594) - div(t, Fact(100), Fact(91)) - div(t, Fact(1000), Fact(991)) - //div(t, Fact(10000), Fact(9991)); // takes too long - disabled for now -} diff --git a/src/pkg/exp/bignum/rational.go b/src/pkg/exp/bignum/rational.go deleted file mode 100644 index 378585e5f..000000000 --- a/src/pkg/exp/bignum/rational.go +++ /dev/null @@ -1,205 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Rational numbers - -package bignum - -import "fmt" - - -// Rational represents a quotient a/b of arbitrary precision. -// -type Rational struct { - a *Integer // numerator - b Natural // denominator -} - - -// MakeRat makes a rational number given a numerator a and a denominator b. -// -func MakeRat(a *Integer, b Natural) *Rational { - f := a.mant.Gcd(b) // f > 0 - if f.Cmp(Nat(1)) != 0 { - a = MakeInt(a.sign, a.mant.Div(f)) - b = b.Div(f) - } - return &Rational{a, b} -} - - -// Rat creates a small rational number with value a0/b0. -// -func Rat(a0 int64, b0 int64) *Rational { - a, b := Int(a0), Int(b0) - if b.sign { - a = a.Neg() - } - return MakeRat(a, b.mant) -} - - -// Value returns the numerator and denominator of x. -// -func (x *Rational) Value() (numerator *Integer, denominator Natural) { - return x.a, x.b -} - - -// Predicates - -// IsZero returns true iff x == 0. -// -func (x *Rational) IsZero() bool { return x.a.IsZero() } - - -// IsNeg returns true iff x < 0. -// -func (x *Rational) IsNeg() bool { return x.a.IsNeg() } - - -// IsPos returns true iff x > 0. -// -func (x *Rational) IsPos() bool { return x.a.IsPos() } - - -// IsInt returns true iff x can be written with a denominator 1 -// in the form x == x'/1; i.e., if x is an integer value. -// -func (x *Rational) IsInt() bool { return x.b.Cmp(Nat(1)) == 0 } - - -// Operations - -// Neg returns the negated value of x. -// -func (x *Rational) Neg() *Rational { return MakeRat(x.a.Neg(), x.b) } - - -// Add returns the sum x + y. -// -func (x *Rational) Add(y *Rational) *Rational { - return MakeRat((x.a.MulNat(y.b)).Add(y.a.MulNat(x.b)), x.b.Mul(y.b)) -} - - -// Sub returns the difference x - y. -// -func (x *Rational) Sub(y *Rational) *Rational { - return MakeRat((x.a.MulNat(y.b)).Sub(y.a.MulNat(x.b)), x.b.Mul(y.b)) -} - - -// Mul returns the product x * y. -// -func (x *Rational) Mul(y *Rational) *Rational { return MakeRat(x.a.Mul(y.a), x.b.Mul(y.b)) } - - -// Quo returns the quotient x / y for y != 0. -// If y == 0, a division-by-zero run-time error occurs. -// -func (x *Rational) Quo(y *Rational) *Rational { - a := x.a.MulNat(y.b) - b := y.a.MulNat(x.b) - if b.IsNeg() { - a = a.Neg() - } - return MakeRat(a, b.mant) -} - - -// Cmp compares x and y. The result is an int value -// -// < 0 if x < y -// == 0 if x == y -// > 0 if x > y -// -func (x *Rational) Cmp(y *Rational) int { return (x.a.MulNat(y.b)).Cmp(y.a.MulNat(x.b)) } - - -// ToString converts x to a string for a given base, with 2 <= base <= 16. -// The string representation is of the form "n" if x is an integer; otherwise -// it is of form "n/d". -// -func (x *Rational) ToString(base uint) string { - s := x.a.ToString(base) - if !x.IsInt() { - s += "/" + x.b.ToString(base) - } - return s -} - - -// String converts x to its decimal string representation. -// x.String() is the same as x.ToString(10). -// -func (x *Rational) String() string { return x.ToString(10) } - - -// Format is a support routine for fmt.Formatter. It accepts -// the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). -// -func (x *Rational) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } - - -// RatFromString returns the rational number corresponding to the -// longest possible prefix of s representing a rational number in a -// given conversion base, the actual conversion base used, and the -// prefix length. The syntax of a rational number is: -// -// rational = mantissa [exponent] . -// mantissa = integer ('/' natural | '.' natural) . -// exponent = ('e'|'E') integer . -// -// If the base argument is 0, the string prefix determines the actual -// conversion base for the mantissa. A prefix of ``0x'' or ``0X'' selects -// base 16; the ``0'' prefix selects base 8. Otherwise the selected base is 10. -// If the mantissa is represented via a division, both the numerator and -// denominator may have different base prefixes; in that case the base of -// of the numerator is returned. If the mantissa contains a decimal point, -// the base for the fractional part is the same as for the part before the -// decimal point and the fractional part does not accept a base prefix. -// The base for the exponent is always 10. -// -func RatFromString(s string, base uint) (*Rational, uint, int) { - // read numerator - a, abase, alen := IntFromString(s, base) - b := Nat(1) - - // read denominator or fraction, if any - var blen int - if alen < len(s) { - ch := s[alen] - if ch == '/' { - alen++ - b, base, blen = NatFromString(s[alen:], base) - } else if ch == '.' { - alen++ - b, base, blen = NatFromString(s[alen:], abase) - assert(base == abase) - f := Nat(uint64(base)).Pow(uint(blen)) - a = MakeInt(a.sign, a.mant.Mul(f).Add(b)) - b = f - } - } - - // read exponent, if any - rlen := alen + blen - if rlen < len(s) { - ch := s[rlen] - if ch == 'e' || ch == 'E' { - rlen++ - e, _, elen := IntFromString(s[rlen:], 10) - rlen += elen - m := Nat(10).Pow(uint(e.mant.Value())) - if e.sign { - b = b.Mul(m) - } else { - a = a.MulNat(m) - } - } - } - - return MakeRat(a, b), base, rlen -} diff --git a/src/pkg/exp/datafmt/Makefile b/src/pkg/exp/datafmt/Makefile index 40543b195..aa9453897 100644 --- a/src/pkg/exp/datafmt/Makefile +++ b/src/pkg/exp/datafmt/Makefile @@ -2,7 +2,7 @@ # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. -include ../../../Make.$(GOARCH) +include ../../../Make.inc TARG=exp/datafmt GOFILES=\ diff --git a/src/pkg/exp/datafmt/datafmt.go b/src/pkg/exp/datafmt/datafmt.go index e77f445b5..46c412342 100644 --- a/src/pkg/exp/datafmt/datafmt.go +++ b/src/pkg/exp/datafmt/datafmt.go @@ -656,7 +656,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool { // Eval formats each argument according to the format // f and returns the resulting []byte and os.Error. If -// an error occured, the []byte contains the partially +// an error occurred, the []byte contains the partially // formatted result. An environment env may be passed // in which is available in custom formatters through // the state parameter. @@ -697,7 +697,7 @@ func (f Format) Eval(env Environment, args ...interface{}) ([]byte, os.Error) { // written and an os.Error, if any. // func (f Format) Fprint(w io.Writer, env Environment, args ...interface{}) (int, os.Error) { - data, err := f.Eval(env, args) + data, err := f.Eval(env, args...) if err != nil { // TODO should we print partial result in case of error? return 0, err @@ -711,7 +711,7 @@ func (f Format) Fprint(w io.Writer, env Environment, args ...interface{}) (int, // number of bytes written and an os.Error, if any. // func (f Format) Print(args ...interface{}) (int, os.Error) { - return f.Fprint(os.Stdout, nil, args) + return f.Fprint(os.Stdout, nil, args...) } @@ -722,7 +722,7 @@ func (f Format) Print(args ...interface{}) (int, os.Error) { // func (f Format) Sprint(args ...interface{}) string { var buf bytes.Buffer - _, err := f.Fprint(&buf, nil, args) + _, err := f.Fprint(&buf, nil, args...) if err != nil { var i interface{} = args fmt.Fprintf(&buf, "--- Sprint(%s) failed: %v", fmt.Sprint(i), err) diff --git a/src/pkg/exp/datafmt/datafmt_test.go b/src/pkg/exp/datafmt/datafmt_test.go index 908894717..f6a09f820 100644 --- a/src/pkg/exp/datafmt/datafmt_test.go +++ b/src/pkg/exp/datafmt/datafmt_test.go @@ -7,11 +7,15 @@ package datafmt import ( "fmt" "testing" + "go/token" ) +var fset = token.NewFileSet() + + func parse(t *testing.T, form string, fmap FormatterMap) Format { - f, err := Parse("", []byte(form), fmap) + f, err := Parse(fset, "", []byte(form), fmap) if err != nil { t.Errorf("Parse(%s): %v", form, err) return nil @@ -24,7 +28,7 @@ func verify(t *testing.T, f Format, expected string, args ...interface{}) { if f == nil { return // allow other tests to run } - result := f.Sprint(args) + result := f.Sprint(args...) if result != expected { t.Errorf( "result : `%s`\nexpected: `%s`\n\n", @@ -97,7 +101,7 @@ func check(t *testing.T, form, expected string, args ...interface{}) { if f == nil { return // allow other tests to run } - result := f.Sprint(args) + result := f.Sprint(args...) if result != expected { t.Errorf( "format : %s\nresult : `%s`\nexpected: `%s`\n\n", diff --git a/src/pkg/exp/datafmt/parser.go b/src/pkg/exp/datafmt/parser.go index de1f1c2a6..a01378ea5 100644 --- a/src/pkg/exp/datafmt/parser.go +++ b/src/pkg/exp/datafmt/parser.go @@ -19,9 +19,10 @@ import ( type parser struct { scanner.ErrorVector scanner scanner.Scanner - pos token.Position // token position - tok token.Token // one token look-ahead - lit []byte // token literal + file *token.File + pos token.Pos // token position + tok token.Token // one token look-ahead + lit []byte // token literal packs map[string]string // PackageName -> ImportPath rules map[string]expr // RuleName -> Expression @@ -39,18 +40,23 @@ func (p *parser) next() { } -func (p *parser) init(filename string, src []byte) { +func (p *parser) init(fset *token.FileSet, filename string, src []byte) { p.ErrorVector.Reset() - p.scanner.Init(filename, src, p, scanner.AllowIllegalChars) // return '@' as token.ILLEGAL w/o error message - p.next() // initializes pos, tok, lit + p.file = p.scanner.Init(fset, filename, src, p, scanner.AllowIllegalChars) // return '@' as token.ILLEGAL w/o error message + p.next() // initializes pos, tok, lit p.packs = make(map[string]string) p.rules = make(map[string]expr) } -func (p *parser) errorExpected(pos token.Position, msg string) { +func (p *parser) error(pos token.Pos, msg string) { + p.Error(p.file.Position(pos), msg) +} + + +func (p *parser) errorExpected(pos token.Pos, msg string) { msg = "expected " + msg - if pos.Offset == p.pos.Offset { + if pos == p.pos { // the error happened at the current position; // make the error message more specific msg += ", found '" + p.tok.String() + "'" @@ -58,11 +64,11 @@ func (p *parser) errorExpected(pos token.Position, msg string) { msg += " " + string(p.lit) } } - p.Error(pos, msg) + p.error(pos, msg) } -func (p *parser) expect(tok token.Token) token.Position { +func (p *parser) expect(tok token.Token) token.Pos { pos := p.pos if p.tok != tok { p.errorExpected(pos, "'"+tok.String()+"'") @@ -87,7 +93,7 @@ func (p *parser) parseTypeName() (string, bool) { if importPath, found := p.packs[name]; found { name = importPath } else { - p.Error(pos, "package not declared: "+name) + p.error(pos, "package not declared: "+name) } p.next() name, isIdent = name+"."+p.parseIdentifier(), false @@ -303,11 +309,11 @@ func (p *parser) parseFormat() { // add package declaration if !isIdent { - p.Error(pos, "illegal package name: "+name) + p.error(pos, "illegal package name: "+name) } else if _, found := p.packs[name]; !found { p.packs[name] = importPath } else { - p.Error(pos, "package already declared: "+name) + p.error(pos, "package already declared: "+name) } case token.ASSIGN: @@ -319,7 +325,7 @@ func (p *parser) parseFormat() { if _, found := p.rules[name]; !found { p.rules[name] = x } else { - p.Error(pos, "format rule already declared: "+name) + p.error(pos, "format rule already declared: "+name) } default: @@ -358,10 +364,10 @@ func remap(p *parser, name string) string { // there are no errors, the result is a Format and the error is nil. // Otherwise the format is nil and a non-empty ErrorList is returned. // -func Parse(filename string, src []byte, fmap FormatterMap) (Format, os.Error) { +func Parse(fset *token.FileSet, filename string, src []byte, fmap FormatterMap) (Format, os.Error) { // parse source var p parser - p.init(filename, src) + p.init(fset, filename, src) p.parseFormat() // add custom formatters, if any diff --git a/src/pkg/exp/draw/Makefile b/src/pkg/exp/draw/Makefile index 7ab574482..6f0f0b2f5 100644 --- a/src/pkg/exp/draw/Makefile +++ b/src/pkg/exp/draw/Makefile @@ -2,12 +2,10 @@ # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. -include ../../../Make.$(GOARCH) +include ../../../Make.inc TARG=exp/draw GOFILES=\ - arith.go\ - color.go\ draw.go\ event.go\ diff --git a/src/pkg/exp/draw/arith.go b/src/pkg/exp/draw/arith.go deleted file mode 100644 index b72242aaa..000000000 --- a/src/pkg/exp/draw/arith.go +++ /dev/null @@ -1,155 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package draw - -// A Point is an X, Y coordinate pair. -type Point struct { - X, Y int -} - -// ZP is the zero Point. -var ZP Point - -// A Rectangle contains the Points with Min.X <= X < Max.X, Min.Y <= Y < Max.Y. -type Rectangle struct { - Min, Max Point -} - -// ZR is the zero Rectangle. -var ZR Rectangle - -// Pt is shorthand for Point{X, Y}. -func Pt(X, Y int) Point { return Point{X, Y} } - -// Rect is shorthand for Rectangle{Pt(x0, y0), Pt(x1, y1)}. -func Rect(x0, y0, x1, y1 int) Rectangle { return Rectangle{Point{x0, y0}, Point{x1, y1}} } - -// Rpt is shorthand for Rectangle{min, max}. -func Rpt(min, max Point) Rectangle { return Rectangle{min, max} } - -// Add returns the sum of p and q: Pt(p.X+q.X, p.Y+q.Y). -func (p Point) Add(q Point) Point { return Point{p.X + q.X, p.Y + q.Y} } - -// Sub returns the difference of p and q: Pt(p.X-q.X, p.Y-q.Y). -func (p Point) Sub(q Point) Point { return Point{p.X - q.X, p.Y - q.Y} } - -// Mul returns p scaled by k: Pt(p.X*k p.Y*k). -func (p Point) Mul(k int) Point { return Point{p.X * k, p.Y * k} } - -// Div returns p divided by k: Pt(p.X/k, p.Y/k). -func (p Point) Div(k int) Point { return Point{p.X / k, p.Y / k} } - -// Eq returns true if p and q are equal. -func (p Point) Eq(q Point) bool { return p.X == q.X && p.Y == q.Y } - -// In returns true if p is within r. -func (p Point) In(r Rectangle) bool { - return p.X >= r.Min.X && p.X < r.Max.X && - p.Y >= r.Min.Y && p.Y < r.Max.Y -} - -// Inset returns the rectangle r inset by n: Rect(r.Min.X+n, r.Min.Y+n, r.Max.X-n, r.Max.Y-n). -func (r Rectangle) Inset(n int) Rectangle { - return Rectangle{Point{r.Min.X + n, r.Min.Y + n}, Point{r.Max.X - n, r.Max.Y - n}} -} - -// Add returns the rectangle r translated by p: Rpt(r.Min.Add(p), r.Max.Add(p)). -func (r Rectangle) Add(p Point) Rectangle { return Rectangle{r.Min.Add(p), r.Max.Add(p)} } - -// Sub returns the rectangle r translated by -p: Rpt(r.Min.Sub(p), r.Max.Sub(p)). -func (r Rectangle) Sub(p Point) Rectangle { return Rectangle{r.Min.Sub(p), r.Max.Sub(p)} } - -// Canon returns a canonical version of r: the returned rectangle -// has Min.X <= Max.X and Min.Y <= Max.Y. -func (r Rectangle) Canon() Rectangle { - if r.Max.X < r.Min.X { - r.Min.X, r.Max.X = r.Max.X, r.Min.X - } - if r.Max.Y < r.Min.Y { - r.Min.Y, r.Max.Y = r.Max.Y, r.Min.Y - } - return r -} - -// Overlaps returns true if r and r1 cross; that is, it returns true if they share any point. -func (r Rectangle) Overlaps(r1 Rectangle) bool { - return r.Min.X < r1.Max.X && r1.Min.X < r.Max.X && - r.Min.Y < r1.Max.Y && r1.Min.Y < r.Max.Y -} - -// Empty retruns true if r contains no points. -func (r Rectangle) Empty() bool { return r.Max.X <= r.Min.X || r.Max.Y <= r.Min.Y } - -// InRect returns true if all the points in r are also in r1. -func (r Rectangle) In(r1 Rectangle) bool { - if r.Empty() { - return true - } - if r1.Empty() { - return false - } - return r1.Min.X <= r.Min.X && r.Max.X <= r1.Max.X && - r1.Min.Y <= r.Min.Y && r.Max.Y <= r1.Max.Y -} - -// Combine returns the smallest rectangle containing all points from r and from r1. -func (r Rectangle) Combine(r1 Rectangle) Rectangle { - if r.Empty() { - return r1 - } - if r1.Empty() { - return r - } - if r.Min.X > r1.Min.X { - r.Min.X = r1.Min.X - } - if r.Min.Y > r1.Min.Y { - r.Min.Y = r1.Min.Y - } - if r.Max.X < r1.Max.X { - r.Max.X = r1.Max.X - } - if r.Max.Y < r1.Max.Y { - r.Max.Y = r1.Max.Y - } - return r -} - -// Clip returns the largest rectangle containing only points shared by r and r1. -func (r Rectangle) Clip(r1 Rectangle) Rectangle { - if r.Empty() { - return r - } - if r1.Empty() { - return r1 - } - if !r.Overlaps(r1) { - return Rectangle{r.Min, r.Min} - } - if r.Min.X < r1.Min.X { - r.Min.X = r1.Min.X - } - if r.Min.Y < r1.Min.Y { - r.Min.Y = r1.Min.Y - } - if r.Max.X > r1.Max.X { - r.Max.X = r1.Max.X - } - if r.Max.Y > r1.Max.Y { - r.Max.Y = r1.Max.Y - } - return r -} - -// Dx returns the width of the rectangle r: r.Max.X - r.Min.X. -func (r Rectangle) Dx() int { return r.Max.X - r.Min.X } - -// Dy returns the width of the rectangle r: r.Max.Y - r.Min.Y. -func (r Rectangle) Dy() int { return r.Max.Y - r.Min.Y } - -// Eq returns true if r and r1 are equal. -func (r Rectangle) Eq(r1 Rectangle) bool { - return r.Min.Eq(r1.Min) && r.Max.Eq(r1.Max) -} diff --git a/src/pkg/exp/draw/color.go b/src/pkg/exp/draw/color.go deleted file mode 100644 index 3fe7b4abc..000000000 --- a/src/pkg/exp/draw/color.go +++ /dev/null @@ -1,105 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package draw - -import "image" - -// A Color represents a color with 8-bit R, G, B, and A values, -// packed into a uint32—0xRRGGBBAA—so that comparison -// is defined on colors. -// Color implements image.Color. -// Color also implements image.Image: it is a -// 10⁹x10⁹-pixel image of uniform color. -type Color uint32 - -// Check that Color implements image.Color and image.Image -var _ image.Color = Black -var _ image.Image = Black - -var ( - Opaque Color = 0xFFFFFFFF - Transparent Color = 0x00000000 - Black Color = 0x000000FF - White Color = 0xFFFFFFFF - Red Color = 0xFF0000FF - Green Color = 0x00FF00FF - Blue Color = 0x0000FFFF - Cyan Color = 0x00FFFFFF - Magenta Color = 0xFF00FFFF - Yellow Color = 0xFFFF00FF - PaleYellow Color = 0xFFFFAAFF - DarkYellow Color = 0xEEEE9EFF - DarkGreen Color = 0x448844FF - PaleGreen Color = 0xAAFFAAFF - MedGreen Color = 0x88CC88FF - DarkBlue Color = 0x000055FF - PaleBlueGreen Color = 0xAAFFFFFF - PaleBlue Color = 0x0000BBFF - BlueGreen Color = 0x008888FF - GreyGreen Color = 0x55AAAAFF - PaleGreyGreen Color = 0x9EEEEEFF - YellowGreen Color = 0x99994CFF - MedBlue Color = 0x000099FF - GreyBlue Color = 0x005DBBFF - PaleGreyBlue Color = 0x4993DDFF - PurpleBlue Color = 0x8888CCFF -) - -func (c Color) RGBA() (r, g, b, a uint32) { - x := uint32(c) - r, g, b, a = x>>24, (x>>16)&0xFF, (x>>8)&0xFF, x&0xFF - r |= r << 8 - g |= g << 8 - b |= b << 8 - a |= a << 8 - return -} - -// SetAlpha returns the color obtained by changing -// c's alpha value to a and scaling r, g, and b appropriately. -func (c Color) SetAlpha(a uint8) Color { - r, g, b, oa := c>>24, (c>>16)&0xFF, (c>>8)&0xFF, c&0xFF - if oa == 0 { - return 0 - } - r = r * Color(a) / oa - if r < 0 { - r = 0 - } - if r > 0xFF { - r = 0xFF - } - g = g * Color(a) / oa - if g < 0 { - g = 0 - } - if g > 0xFF { - g = 0xFF - } - b = b * Color(a) / oa - if b < 0 { - b = 0 - } - if b > 0xFF { - b = 0xFF - } - return r<<24 | g<<16 | b<<8 | Color(a) -} - -func (c Color) Width() int { return 1e9 } - -func (c Color) Height() int { return 1e9 } - -func (c Color) At(x, y int) image.Color { return c } - -func toColor(color image.Color) image.Color { - if c, ok := color.(Color); ok { - return c - } - r, g, b, a := color.RGBA() - return Color(r>>8<<24 | g>>8<<16 | b>>8<<8 | a>>8) -} - -func (c Color) ColorModel() image.ColorModel { return image.ColorModelFunc(toColor) } diff --git a/src/pkg/exp/draw/draw.go b/src/pkg/exp/draw/draw.go index 415dd99ac..1d0729d92 100644 --- a/src/pkg/exp/draw/draw.go +++ b/src/pkg/exp/draw/draw.go @@ -8,8 +8,6 @@ // and the X Render extension. package draw -// BUG(rsc): This is a toy library and not ready for production use. - import "image" // m is the maximum color value returned by image.Color.RGBA. @@ -34,22 +32,22 @@ type Image interface { } // Draw calls DrawMask with a nil mask and an Over op. -func Draw(dst Image, r Rectangle, src image.Image, sp Point) { - DrawMask(dst, r, src, sp, nil, ZP, Over) +func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) { + DrawMask(dst, r, src, sp, nil, image.ZP, Over) } // DrawMask aligns r.Min in dst with sp in src and mp in mask and then replaces the rectangle r // in dst with the result of a Porter-Duff composition. A nil mask is treated as opaque. -// The implementation is simple and slow. -// TODO(nigeltao): Optimize this. -func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Image, mp Point, op Op) { - dx, dy := src.Width()-sp.X, src.Height()-sp.Y +func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) { + sb := src.Bounds() + dx, dy := sb.Max.X-sp.X, sb.Max.Y-sp.Y if mask != nil { - if dx > mask.Width()-mp.X { - dx = mask.Width() - mp.X + mb := mask.Bounds() + if dx > mb.Max.X-mp.X { + dx = mb.Max.X - mp.X } - if dy > mask.Height()-mp.Y { - dy = mask.Height() - mp.Y + if dy > mb.Max.Y-mp.Y { + dy = mb.Max.Y - mp.Y } } if r.Dx() > dx { @@ -58,45 +56,38 @@ func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Imag if r.Dy() > dy { r.Max.Y = r.Min.Y + dy } - - // TODO(nigeltao): Clip r to dst's bounding box, and handle the case when sp or mp has negative X or Y. - // TODO(nigeltao): Ensure that r is well formed, i.e. r.Max.X >= r.Min.X and likewise for Y. + r = r.Intersect(dst.Bounds()) + if r.Empty() { + return + } // Fast paths for special cases. If none of them apply, then we fall back to a general but slow implementation. if dst0, ok := dst.(*image.RGBA); ok { if op == Over { if mask == nil { - if src0, ok := src.(image.ColorImage); ok { + if src0, ok := src.(*image.ColorImage); ok { drawFillOver(dst0, r, src0) return } if src0, ok := src.(*image.RGBA); ok { - if dst0 == src0 && r.Overlaps(r.Add(sp.Sub(r.Min))) { - // TODO(nigeltao): Implement a fast path for the overlapping case. - } else { - drawCopyOver(dst0, r, src0, sp) - return - } + drawCopyOver(dst0, r, src0, sp) + return } } else if mask0, ok := mask.(*image.Alpha); ok { - if src0, ok := src.(image.ColorImage); ok { + if src0, ok := src.(*image.ColorImage); ok { drawGlyphOver(dst0, r, src0, mask0, mp) return } } } else { if mask == nil { - if src0, ok := src.(image.ColorImage); ok { + if src0, ok := src.(*image.ColorImage); ok { drawFillSrc(dst0, r, src0) return } if src0, ok := src.(*image.RGBA); ok { - if dst0 == src0 && r.Overlaps(r.Add(sp.Sub(r.Min))) { - // TODO(nigeltao): Implement a fast path for the overlapping case. - } else { - drawCopySrc(dst0, r, src0, sp) - return - } + drawCopySrc(dst0, r, src0, sp) + return } } } @@ -158,66 +149,96 @@ func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Imag } } -func drawFillOver(dst *image.RGBA, r Rectangle, src image.ColorImage) { +func drawFillOver(dst *image.RGBA, r image.Rectangle, src *image.ColorImage) { cr, cg, cb, ca := src.RGBA() // The 0x101 is here for the same reason as in drawRGBA. a := (m - ca) * 0x101 x0, x1 := r.Min.X, r.Max.X y0, y1 := r.Min.Y, r.Max.Y for y := y0; y != y1; y++ { - dpix := dst.Pixel[y] - for x := x0; x != x1; x++ { - rgba := dpix[x] + dbase := y * dst.Stride + dpix := dst.Pix[dbase+x0 : dbase+x1] + for i, rgba := range dpix { dr := (uint32(rgba.R)*a)/m + cr dg := (uint32(rgba.G)*a)/m + cg db := (uint32(rgba.B)*a)/m + cb da := (uint32(rgba.A)*a)/m + ca - dpix[x] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} + dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} } } } -func drawCopyOver(dst *image.RGBA, r Rectangle, src *image.RGBA, sp Point) { - x0, x1 := r.Min.X, r.Max.X - y0, y1 := r.Min.Y, r.Max.Y - for y, sy := y0, sp.Y; y != y1; y, sy = y+1, sy+1 { - dpix := dst.Pixel[y] - spix := src.Pixel[sy] - for x, sx := x0, sp.X; x != x1; x, sx = x+1, sx+1 { - // For unknown reasons, even though both dpix[x] and spix[sx] are +func drawCopyOver(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.Point) { + dx0, dx1 := r.Min.X, r.Max.X + dy0, dy1 := r.Min.Y, r.Max.Y + nrows := dy1 - dy0 + sx0, sx1 := sp.X, sp.X+dx1-dx0 + d0 := dy0*dst.Stride + dx0 + d1 := dy0*dst.Stride + dx1 + s0 := sp.Y*src.Stride + sx0 + s1 := sp.Y*src.Stride + sx1 + var ( + ddelta, sdelta int + i0, i1, idelta int + ) + if r.Min.Y < sp.Y || r.Min.Y == sp.Y && r.Min.X <= sp.X { + ddelta = dst.Stride + sdelta = src.Stride + i0, i1, idelta = 0, d1-d0, +1 + } else { + // If the source start point is higher than the destination start point, or equal height but to the left, + // then we compose the rows in right-to-left, bottom-up order instead of left-to-right, top-down. + d0 += (nrows - 1) * dst.Stride + d1 += (nrows - 1) * dst.Stride + s0 += (nrows - 1) * src.Stride + s1 += (nrows - 1) * src.Stride + ddelta = -dst.Stride + sdelta = -src.Stride + i0, i1, idelta = d1-d0-1, -1, -1 + } + for ; nrows > 0; nrows-- { + dpix := dst.Pix[d0:d1] + spix := src.Pix[s0:s1] + for i := i0; i != i1; i += idelta { + // For unknown reasons, even though both dpix[i] and spix[i] are // image.RGBAColors, on an x86 CPU it seems fastest to call RGBA // for the source but to do it manually for the destination. - sr, sg, sb, sa := spix[sx].RGBA() - drgba := dpix[x] - dr := uint32(drgba.R) - dg := uint32(drgba.G) - db := uint32(drgba.B) - da := uint32(drgba.A) + sr, sg, sb, sa := spix[i].RGBA() + rgba := dpix[i] + dr := uint32(rgba.R) + dg := uint32(rgba.G) + db := uint32(rgba.B) + da := uint32(rgba.A) // The 0x101 is here for the same reason as in drawRGBA. a := (m - sa) * 0x101 dr = (dr*a)/m + sr dg = (dg*a)/m + sg db = (db*a)/m + sb da = (da*a)/m + sa - dpix[x] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} + dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} } + d0 += ddelta + d1 += ddelta + s0 += sdelta + s1 += sdelta } } -func drawGlyphOver(dst *image.RGBA, r Rectangle, src image.ColorImage, mask *image.Alpha, mp Point) { +func drawGlyphOver(dst *image.RGBA, r image.Rectangle, src *image.ColorImage, mask *image.Alpha, mp image.Point) { x0, x1 := r.Min.X, r.Max.X y0, y1 := r.Min.Y, r.Max.Y cr, cg, cb, ca := src.RGBA() for y, my := y0, mp.Y; y != y1; y, my = y+1, my+1 { - dpix := dst.Pixel[y] - mpix := mask.Pixel[my] - for x, mx := x0, mp.X; x != x1; x, mx = x+1, mx+1 { - ma := uint32(mpix[mx].A) + dbase := y * dst.Stride + dpix := dst.Pix[dbase+x0 : dbase+x1] + mbase := my * mask.Stride + mpix := mask.Pix[mbase+mp.X:] + for i, rgba := range dpix { + ma := uint32(mpix[i].A) if ma == 0 { continue } ma |= ma << 8 - rgba := dpix[x] dr := uint32(rgba.R) dg := uint32(rgba.G) db := uint32(rgba.B) @@ -228,12 +249,12 @@ func drawGlyphOver(dst *image.RGBA, r Rectangle, src image.ColorImage, mask *ima dg = (dg*a + cg*ma) / m db = (db*a + cb*ma) / m da = (da*a + ca*ma) / m - dpix[x] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} + dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)} } } } -func drawFillSrc(dst *image.RGBA, r Rectangle, src image.ColorImage) { +func drawFillSrc(dst *image.RGBA, r image.Rectangle, src *image.ColorImage) { if r.Dy() < 1 { return } @@ -244,26 +265,53 @@ func drawFillSrc(dst *image.RGBA, r Rectangle, src image.ColorImage) { // then use the first row as the slice source for the remaining rows. dx0, dx1 := r.Min.X, r.Max.X dy0, dy1 := r.Min.Y, r.Max.Y - firstRow := dst.Pixel[dy0] - for x := dx0; x < dx1; x++ { - firstRow[x] = color + dbase := dy0 * dst.Stride + i0, i1 := dbase+dx0, dbase+dx1 + firstRow := dst.Pix[i0:i1] + for i := range firstRow { + firstRow[i] = color } - copySrc := firstRow[dx0:dx1] for y := dy0 + 1; y < dy1; y++ { - copy(dst.Pixel[y][dx0:dx1], copySrc) + i0 += dst.Stride + i1 += dst.Stride + copy(dst.Pix[i0:i1], firstRow) } } -func drawCopySrc(dst *image.RGBA, r Rectangle, src *image.RGBA, sp Point) { +func drawCopySrc(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.Point) { dx0, dx1 := r.Min.X, r.Max.X dy0, dy1 := r.Min.Y, r.Max.Y + nrows := dy1 - dy0 sx0, sx1 := sp.X, sp.X+dx1-dx0 - for y, sy := dy0, sp.Y; y < dy1; y, sy = y+1, sy+1 { - copy(dst.Pixel[y][dx0:dx1], src.Pixel[sy][sx0:sx1]) + d0 := dy0*dst.Stride + dx0 + d1 := dy0*dst.Stride + dx1 + s0 := sp.Y*src.Stride + sx0 + s1 := sp.Y*src.Stride + sx1 + var ddelta, sdelta int + if r.Min.Y <= sp.Y { + ddelta = dst.Stride + sdelta = src.Stride + } else { + // If the source start point is higher than the destination start point, then we compose the rows + // in bottom-up order instead of top-down. Unlike the drawCopyOver function, we don't have to + // check the x co-ordinates because the built-in copy function can handle overlapping slices. + d0 += (nrows - 1) * dst.Stride + d1 += (nrows - 1) * dst.Stride + s0 += (nrows - 1) * src.Stride + s1 += (nrows - 1) * src.Stride + ddelta = -dst.Stride + sdelta = -src.Stride + } + for ; nrows > 0; nrows-- { + copy(dst.Pix[d0:d1], src.Pix[s0:s1]) + d0 += ddelta + d1 += ddelta + s0 += sdelta + s1 += sdelta } } -func drawRGBA(dst *image.RGBA, r Rectangle, src image.Image, sp Point, mask image.Image, mp Point, op Op) { +func drawRGBA(dst *image.RGBA, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) { x0, x1, dx := r.Min.X, r.Max.X, 1 y0, y1, dy := r.Min.Y, r.Max.Y, 1 if image.Image(dst) == src && r.Overlaps(r.Add(sp.Sub(r.Min))) { @@ -278,7 +326,7 @@ func drawRGBA(dst *image.RGBA, r Rectangle, src image.Image, sp Point, mask imag for y := y0; y != y1; y, sy, my = y+dy, sy+dy, my+dy { sx := sp.X + x0 - r.Min.X mx := mp.X + x0 - r.Min.X - dpix := dst.Pixel[y] + dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride] for x := x0; x != x1; x, sx, mx = x+dx, sx+dx, mx+dx { ma := uint32(m) if mask != nil { @@ -313,26 +361,3 @@ func drawRGBA(dst *image.RGBA, r Rectangle, src image.Image, sp Point, mask imag } } } - -// Border aligns r.Min in dst with sp in src and then replaces pixels -// in a w-pixel border around r in dst with the result of the Porter-Duff compositing -// operation ``src over dst.'' If w is positive, the border extends w pixels inside r. -// If w is negative, the border extends w pixels outside r. -func Border(dst Image, r Rectangle, w int, src image.Image, sp Point) { - i := w - if i > 0 { - // inside r - Draw(dst, Rect(r.Min.X, r.Min.Y, r.Max.X, r.Min.Y+i), src, sp) // top - Draw(dst, Rect(r.Min.X, r.Min.Y+i, r.Min.X+i, r.Max.Y-i), src, sp.Add(Pt(0, i))) // left - Draw(dst, Rect(r.Max.X-i, r.Min.Y+i, r.Max.X, r.Max.Y-i), src, sp.Add(Pt(r.Dx()-i, i))) // right - Draw(dst, Rect(r.Min.X, r.Max.Y-i, r.Max.X, r.Max.Y), src, sp.Add(Pt(0, r.Dy()-i))) // bottom - return - } - - // outside r; - i = -i - Draw(dst, Rect(r.Min.X-i, r.Min.Y-i, r.Max.X+i, r.Min.Y), src, sp.Add(Pt(-i, -i))) // top - Draw(dst, Rect(r.Min.X-i, r.Min.Y, r.Min.X, r.Max.Y), src, sp.Add(Pt(-i, 0))) // left - Draw(dst, Rect(r.Max.X, r.Min.Y, r.Max.X+i, r.Max.Y), src, sp.Add(Pt(r.Dx(), 0))) // right - Draw(dst, Rect(r.Min.X-i, r.Max.Y, r.Max.X+i, r.Max.Y+i), src, sp.Add(Pt(-i, 0))) // bottom -} diff --git a/src/pkg/exp/draw/draw_test.go b/src/pkg/exp/draw/draw_test.go index e9fde2535..90c9e823d 100644 --- a/src/pkg/exp/draw/draw_test.go +++ b/src/pkg/exp/draw/draw_test.go @@ -16,11 +16,11 @@ func eq(c0, c1 image.Color) bool { } func fillBlue(alpha int) image.Image { - return image.ColorImage{image.RGBAColor{0, 0, uint8(alpha), uint8(alpha)}} + return image.NewColorImage(image.RGBAColor{0, 0, uint8(alpha), uint8(alpha)}) } func fillAlpha(alpha int) image.Image { - return image.ColorImage{image.AlphaColor{uint8(alpha)}} + return image.NewColorImage(image.AlphaColor{uint8(alpha)}) } func vgradGreen(alpha int) image.Image { @@ -53,6 +53,16 @@ func hgradRed(alpha int) Image { return m } +func gradYellow(alpha int) Image { + m := image.NewRGBA(16, 16) + for y := 0; y < 16; y++ { + for x := 0; x < 16; x++ { + m.Set(x, y, image.RGBAColor{uint8(x * alpha / 15), uint8(y * alpha / 15), 0, uint8(alpha)}) + } + } + return m +} + type drawTest struct { desc string src image.Image @@ -63,54 +73,62 @@ type drawTest struct { var drawTests = []drawTest{ // Uniform mask (0% opaque). - drawTest{"nop", vgradGreen(255), fillAlpha(0), Over, image.RGBAColor{136, 0, 0, 255}}, - drawTest{"clear", vgradGreen(255), fillAlpha(0), Src, image.RGBAColor{0, 0, 0, 0}}, + {"nop", vgradGreen(255), fillAlpha(0), Over, image.RGBAColor{136, 0, 0, 255}}, + {"clear", vgradGreen(255), fillAlpha(0), Src, image.RGBAColor{0, 0, 0, 0}}, // Uniform mask (100%, 75%, nil) and uniform source. // At (x, y) == (8, 8): // The destination pixel is {136, 0, 0, 255}. // The source pixel is {0, 0, 90, 90}. - drawTest{"fill", fillBlue(90), fillAlpha(255), Over, image.RGBAColor{88, 0, 90, 255}}, - drawTest{"fillSrc", fillBlue(90), fillAlpha(255), Src, image.RGBAColor{0, 0, 90, 90}}, - drawTest{"fillAlpha", fillBlue(90), fillAlpha(192), Over, image.RGBAColor{100, 0, 68, 255}}, - drawTest{"fillAlphaSrc", fillBlue(90), fillAlpha(192), Src, image.RGBAColor{0, 0, 68, 68}}, - drawTest{"fillNil", fillBlue(90), nil, Over, image.RGBAColor{88, 0, 90, 255}}, - drawTest{"fillNilSrc", fillBlue(90), nil, Src, image.RGBAColor{0, 0, 90, 90}}, + {"fill", fillBlue(90), fillAlpha(255), Over, image.RGBAColor{88, 0, 90, 255}}, + {"fillSrc", fillBlue(90), fillAlpha(255), Src, image.RGBAColor{0, 0, 90, 90}}, + {"fillAlpha", fillBlue(90), fillAlpha(192), Over, image.RGBAColor{100, 0, 68, 255}}, + {"fillAlphaSrc", fillBlue(90), fillAlpha(192), Src, image.RGBAColor{0, 0, 68, 68}}, + {"fillNil", fillBlue(90), nil, Over, image.RGBAColor{88, 0, 90, 255}}, + {"fillNilSrc", fillBlue(90), nil, Src, image.RGBAColor{0, 0, 90, 90}}, // Uniform mask (100%, 75%, nil) and variable source. // At (x, y) == (8, 8): // The destination pixel is {136, 0, 0, 255}. // The source pixel is {0, 48, 0, 90}. - drawTest{"copy", vgradGreen(90), fillAlpha(255), Over, image.RGBAColor{88, 48, 0, 255}}, - drawTest{"copySrc", vgradGreen(90), fillAlpha(255), Src, image.RGBAColor{0, 48, 0, 90}}, - drawTest{"copyAlpha", vgradGreen(90), fillAlpha(192), Over, image.RGBAColor{100, 36, 0, 255}}, - drawTest{"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, image.RGBAColor{0, 36, 0, 68}}, - drawTest{"copyNil", vgradGreen(90), nil, Over, image.RGBAColor{88, 48, 0, 255}}, - drawTest{"copyNilSrc", vgradGreen(90), nil, Src, image.RGBAColor{0, 48, 0, 90}}, + {"copy", vgradGreen(90), fillAlpha(255), Over, image.RGBAColor{88, 48, 0, 255}}, + {"copySrc", vgradGreen(90), fillAlpha(255), Src, image.RGBAColor{0, 48, 0, 90}}, + {"copyAlpha", vgradGreen(90), fillAlpha(192), Over, image.RGBAColor{100, 36, 0, 255}}, + {"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, image.RGBAColor{0, 36, 0, 68}}, + {"copyNil", vgradGreen(90), nil, Over, image.RGBAColor{88, 48, 0, 255}}, + {"copyNilSrc", vgradGreen(90), nil, Src, image.RGBAColor{0, 48, 0, 90}}, // Variable mask and variable source. // At (x, y) == (8, 8): // The destination pixel is {136, 0, 0, 255}. // The source pixel is {0, 0, 255, 255}. // The mask pixel's alpha is 102, or 40%. - drawTest{"generic", fillBlue(255), vgradAlpha(192), Over, image.RGBAColor{81, 0, 102, 255}}, - drawTest{"genericSrc", fillBlue(255), vgradAlpha(192), Src, image.RGBAColor{0, 0, 102, 102}}, + {"generic", fillBlue(255), vgradAlpha(192), Over, image.RGBAColor{81, 0, 102, 255}}, + {"genericSrc", fillBlue(255), vgradAlpha(192), Src, image.RGBAColor{0, 0, 102, 102}}, } -func makeGolden(dst image.Image, t drawTest) image.Image { +func makeGolden(dst, src, mask image.Image, op Op) image.Image { // Since golden is a newly allocated image, we don't have to check if the // input source and mask images and the output golden image overlap. - golden := image.NewRGBA(dst.Width(), dst.Height()) - for y := 0; y < golden.Height(); y++ { - my, sy := y, y - for x := 0; x < golden.Width(); x++ { - mx, sx := x, x + b := dst.Bounds() + sx0 := src.Bounds().Min.X - b.Min.X + sy0 := src.Bounds().Min.Y - b.Min.Y + var mx0, my0 int + if mask != nil { + mx0 = mask.Bounds().Min.X - b.Min.X + my0 = mask.Bounds().Min.Y - b.Min.Y + } + golden := image.NewRGBA(b.Max.X, b.Max.Y) + for y := b.Min.Y; y < b.Max.Y; y++ { + my, sy := my0+y, sy0+y + for x := b.Min.X; x < b.Max.X; x++ { + mx, sx := mx0+x, sx0+x const M = 1<<16 - 1 var dr, dg, db, da uint32 - if t.op == Over { + if op == Over { dr, dg, db, da = dst.At(x, y).RGBA() } - sr, sg, sb, sa := t.src.At(sx, sy).RGBA() + sr, sg, sb, sa := src.At(sx, sy).RGBA() ma := uint32(M) - if t.mask != nil { - _, _, _, ma = t.mask.At(mx, my).RGBA() + if mask != nil { + _, _, _, ma = mask.At(mx, my).RGBA() } a := M - (sa * ma / M) golden.Set(x, y, image.RGBA64Color{ @@ -121,6 +139,7 @@ func makeGolden(dst image.Image, t drawTest) image.Image { }) } } + golden.Rect = b return golden } @@ -129,9 +148,14 @@ loop: for _, test := range drawTests { dst := hgradRed(255) // Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation. - golden := makeGolden(dst, test) + golden := makeGolden(dst, test.src, test.mask, test.op) + b := dst.Bounds() + if !b.Eq(golden.Bounds()) { + t.Errorf("draw %s: bounds %v versus %v", test.desc, dst.Bounds(), golden.Bounds()) + continue + } // Draw the same combination onto the actual dst using the optimized DrawMask implementation. - DrawMask(dst, Rect(0, 0, dst.Width(), dst.Height()), test.src, ZP, test.mask, ZP, test.op) + DrawMask(dst, b, test.src, image.ZP, test.mask, image.ZP, test.op) // Check that the resultant pixel at (8, 8) matches what we expect // (the expected value can be verified by hand). if !eq(dst.At(8, 8), test.expected) { @@ -139,8 +163,8 @@ loop: continue } // Check that the resultant dst image matches the golden output. - for y := 0; y < golden.Height(); y++ { - for x := 0; x < golden.Width(); x++ { + for y := b.Min.Y; y < b.Max.Y; y++ { + for x := b.Min.X; x < b.Max.X; x++ { if !eq(dst.At(x, y), golden.At(x, y)) { t.Errorf("draw %s: at (%d, %d), %v versus golden %v", test.desc, x, y, dst.At(x, y), golden.At(x, y)) continue loop @@ -150,6 +174,45 @@ loop: } } +func TestDrawOverlap(t *testing.T) { + for _, op := range []Op{Over, Src} { + for yoff := -2; yoff <= 2; yoff++ { + loop: + for xoff := -2; xoff <= 2; xoff++ { + m := gradYellow(127).(*image.RGBA) + dst := &image.RGBA{ + Pix: m.Pix, + Stride: m.Stride, + Rect: image.Rect(5, 5, 10, 10), + } + src := &image.RGBA{ + Pix: m.Pix, + Stride: m.Stride, + Rect: image.Rect(5+xoff, 5+yoff, 10+xoff, 10+yoff), + } + // Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation. + golden := makeGolden(dst, src, nil, op) + b := dst.Bounds() + if !b.Eq(golden.Bounds()) { + t.Errorf("drawOverlap xoff=%d,yoff=%d: bounds %v versus %v", xoff, yoff, dst.Bounds(), golden.Bounds()) + continue + } + // Draw the same combination onto the actual dst using the optimized DrawMask implementation. + DrawMask(dst, b, src, src.Bounds().Min, nil, image.ZP, op) + // Check that the resultant dst image matches the golden output. + for y := b.Min.Y; y < b.Max.Y; y++ { + for x := b.Min.X; x < b.Max.X; x++ { + if !eq(dst.At(x, y), golden.At(x, y)) { + t.Errorf("drawOverlap xoff=%d,yoff=%d: at (%d, %d), %v versus golden %v", xoff, yoff, x, y, dst.At(x, y), golden.At(x, y)) + continue loop + } + } + } + } + } + } +} + // TestIssue836 verifies http://code.google.com/p/go/issues/detail?id=836. func TestIssue836(t *testing.T) { a := image.NewRGBA(1, 1) @@ -158,7 +221,7 @@ func TestIssue836(t *testing.T) { b.Set(1, 0, image.RGBAColor{0, 0, 5, 5}) b.Set(0, 1, image.RGBAColor{0, 5, 0, 5}) b.Set(1, 1, image.RGBAColor{5, 0, 0, 5}) - Draw(a, Rect(0, 0, 1, 1), b, Pt(1, 1)) + Draw(a, image.Rect(0, 0, 1, 1), b, image.Pt(1, 1)) if !eq(image.RGBAColor{5, 0, 0, 5}, a.At(0, 0)) { t.Errorf("Issue 836: want %v got %v", image.RGBAColor{5, 0, 0, 5}, a.At(0, 0)) } diff --git a/src/pkg/exp/draw/event.go b/src/pkg/exp/draw/event.go index 155922d1c..b777d912e 100644 --- a/src/pkg/exp/draw/event.go +++ b/src/pkg/exp/draw/event.go @@ -4,43 +4,53 @@ package draw -// A Context represents a single graphics window. -type Context interface { - // Screen returns an editable Image of window. +import ( + "image" + "os" +) + +// A Window represents a single graphics window. +type Window interface { + // Screen returns an editable Image for the window. Screen() Image - // FlushImage flushes changes made to Screen() back to screen. FlushImage() + // EventChan returns a channel carrying UI events such as key presses, + // mouse movements and window resizes. + EventChan() <-chan interface{} + // Close closes the window. + Close() os.Error +} - // KeyboardChan returns a channel carrying keystrokes. - // An event is sent each time a key is pressed or released. +// A KeyEvent is sent for a key press or release. +type KeyEvent struct { // The value k represents key k being pressed. // The value -k represents key k being released. // The specific set of key values is not specified, - // but ordinary character represent themselves. - KeyboardChan() <-chan int - - // MouseChan returns a channel carrying mouse events. - // A new event is sent each time the mouse moves or a - // button is pressed or released. - MouseChan() <-chan Mouse + // but ordinary characters represent themselves. + Key int +} - // ResizeChan returns a channel carrying resize events. - // An event is sent each time the window is resized; - // the client should respond by calling Screen() to obtain - // the new screen image. - // The value sent on the channel is always ``true'' and can be ignored. - ResizeChan() <-chan bool +// A MouseEvent is sent for a button press or release or for a mouse movement. +type MouseEvent struct { + // Buttons is a bit mask of buttons: 1<<0 is left, 1<<1 middle, 1<<2 right. + // It represents button state and not necessarily the state delta: bit 0 + // being on means that the left mouse button is down, but does not imply + // that the same button was up in the previous MouseEvent. + Buttons int + // Loc is the location of the cursor. + Loc image.Point + // Nsec is the event's timestamp. + Nsec int64 +} - // QuitChan returns a channel carrying quit requests. - // After reading a value from the quit channel, the application - // should exit. - QuitChan() <-chan bool +// A ConfigEvent is sent each time the window's color model or size changes. +// The client should respond by calling Window.Screen to obtain a new image. +type ConfigEvent struct { + Config image.Config } -// A Mouse represents the state of the mouse. -type Mouse struct { - Buttons int // bit mask of buttons: 1<<0 is left, 1<<1 middle, 1<<2 right - Point // location of cursor - Nsec int64 // time stamp +// An ErrEvent is sent when an error occurs. +type ErrEvent struct { + Err os.Error } diff --git a/src/pkg/exp/draw/x11/Makefile b/src/pkg/exp/draw/x11/Makefile index d4e65ca73..205b3a65b 100644 --- a/src/pkg/exp/draw/x11/Makefile +++ b/src/pkg/exp/draw/x11/Makefile @@ -2,7 +2,7 @@ # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. -include ../../../../Make.$(GOARCH) +include ../../../../Make.inc TARG=exp/draw/x11 GOFILES=\ diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/draw/x11/conn.go index 979ce2b7d..da2181536 100644 --- a/src/pkg/exp/draw/x11/conn.go +++ b/src/pkg/exp/draw/x11/conn.go @@ -8,17 +8,17 @@ // A summary of the wire format can be found in XCB's xproto.xml. package x11 -// BUG(nigeltao): This is a toy library and not ready for production use. - import ( "bufio" "exp/draw" "image" "io" + "log" "net" "os" "strconv" "strings" + "time" ) type resID uint32 // X resource IDs. @@ -35,9 +35,6 @@ const ( ) type conn struct { - // TODO(nigeltao): Figure out which goroutine should be responsible for closing c, - // or if there is a race condition if one goroutine calls c.Close whilst another one - // is reading from r, or writing to w. c io.Closer r *bufio.Reader w *bufio.Writer @@ -45,11 +42,8 @@ type conn struct { gc, window, root, visual resID img *image.RGBA - kbd chan int - mouse chan draw.Mouse - resize chan bool - quit chan bool - mouseState draw.Mouse + eventc chan interface{} + mouseState draw.MouseEvent buf [256]byte // General purpose scratch buffer. @@ -58,25 +52,24 @@ type conn struct { flushBuf1 [4 * 1024]byte } -// flusher runs in its own goroutine, serving both FlushImage calls directly from the exp/draw client -// and indirectly from X expose events. It paints c.img to the X server via PutImage requests. -func (c *conn) flusher() { - for { - _ = <-c.flush - if closed(c.flush) { - return +// writeSocket runs in its own goroutine, serving both FlushImage calls +// directly from the exp/draw client and indirectly from X expose events. +// It paints c.img to the X server via PutImage requests. +func (c *conn) writeSocket() { + defer c.c.Close() + for _ = range c.flush { + b := c.img.Bounds() + if b.Empty() { + continue } - // Each X request has a 16-bit length (in terms of 4-byte units). To avoid going over // this limit, we send PutImage for each row of the image, rather than trying to paint // the entire image in one X request. This approach could easily be optimized (or the // X protocol may have an escape sequence to delimit very large requests). // TODO(nigeltao): See what XCB's xcb_put_image does in this situation. - w, h := c.img.Width(), c.img.Height() - units := 6 + w - if units > 0xffff || h > 0xffff { - // This window is too large for X. - close(c.flush) + units := 6 + b.Dx() + if units > 0xffff || b.Dy() > 0xffff { + log.Print("x11: window is too large for PutImage") return } @@ -86,19 +79,20 @@ func (c *conn) flusher() { c.flushBuf0[3] = uint8(units >> 8) setU32LE(c.flushBuf0[4:8], uint32(c.window)) setU32LE(c.flushBuf0[8:12], uint32(c.gc)) - setU32LE(c.flushBuf0[12:16], 1<<16|uint32(w)) + setU32LE(c.flushBuf0[12:16], 1<<16|uint32(b.Dx())) c.flushBuf0[21] = 0x18 // depth = 24 bits. - for y := 0; y < h; y++ { + for y := b.Min.Y; y < b.Max.Y; y++ { setU32LE(c.flushBuf0[16:20], uint32(y<<16)) - _, err := c.w.Write(c.flushBuf0[0:24]) - if err != nil { - close(c.flush) + if _, err := c.w.Write(c.flushBuf0[0:24]); err != nil { + if err != os.EOF { + log.Println("x11:", err.String()) + } return } - p := c.img.Pixel[y] - for x := 0; x < w; { - nx := w - x + p := c.img.Pix[y*c.img.Stride : (y+1)*c.img.Stride] + for x := b.Min.X; x < b.Max.X; { + nx := b.Max.X - x if nx > len(c.flushBuf1)/4 { nx = len(c.flushBuf1) / 4 } @@ -108,15 +102,18 @@ func (c *conn) flusher() { c.flushBuf1[4*i+2] = rgba.R } x += nx - _, err := c.w.Write(c.flushBuf1[0 : 4*nx]) - if err != nil { - close(c.flush) + if _, err := c.w.Write(c.flushBuf1[0 : 4*nx]); err != nil { + if err != os.EOF { + log.Println("x11:", err.String()) + } return } } } - if c.w.Flush() != nil { - close(c.flush) + if err := c.w.Flush(); err != nil { + if err != os.EOF { + log.Println("x11:", err.String()) + } return } } @@ -131,32 +128,32 @@ func (c *conn) FlushImage() { _ = c.flush <- false } -func (c *conn) KeyboardChan() <-chan int { return c.kbd } - -func (c *conn) MouseChan() <-chan draw.Mouse { return c.mouse } - -func (c *conn) ResizeChan() <-chan bool { return c.resize } +func (c *conn) Close() os.Error { + // Shut down the writeSocket goroutine. This will close the socket to the + // X11 server, which will cause c.eventc to close. + close(c.flush) + for _ = range c.eventc { + // Drain the channel to allow the readSocket goroutine to shut down. + } + return nil +} -func (c *conn) QuitChan() <-chan bool { return c.quit } +func (c *conn) EventChan() <-chan interface{} { return c.eventc } -// pumper runs in its own goroutine, reading X events and demuxing them over the kbd / mouse / resize / quit chans. -func (c *conn) pumper() { +// readSocket runs in its own goroutine, reading X events and sending draw +// events on c's EventChan. +func (c *conn) readSocket() { var ( keymap [256][]int keysymsPerKeycode int ) - defer close(c.flush) - // TODO(nigeltao): Is this the right place for defer c.c.Close()? - // TODO(nigeltao): Should we explicitly defer close our kbd/mouse/resize/quit chans? + defer close(c.eventc) for { // X events are always 32 bytes long. - _, err := io.ReadFull(c.r, c.buf[0:32]) - if err != nil { - // TODO(nigeltao): should draw.Context expose err? - // TODO(nigeltao): should we do c.quit<-true? Should c.quit be a buffered channel? - // Or is c.quit only for non-exceptional closing (e.g. when the window manager destroys - // our window), and not for e.g. an I/O error? - os.Stderr.Write([]byte(err.String())) + if _, err := io.ReadFull(c.r, c.buf[0:32]); err != nil { + if err != os.EOF { + c.eventc <- draw.ErrEvent{err} + } return } switch c.buf[0] { @@ -165,7 +162,7 @@ func (c *conn) pumper() { if cookie != 1 { // We issued only one request (GetKeyboardMapping) with a cookie of 1, // so we shouldn't get any other reply from the X server. - os.Stderr.Write([]byte("exp/draw/x11: unexpected cookie\n")) + c.eventc <- draw.ErrEvent{os.NewError("x11: unexpected cookie")} return } keysymsPerKeycode = int(c.buf[1]) @@ -178,7 +175,9 @@ func (c *conn) pumper() { for j := range m { u, err := readU32LE(c.r, c.buf[0:4]) if err != nil { - os.Stderr.Write([]byte(err.String())) + if err != os.EOF { + c.eventc <- draw.ErrEvent{err} + } return } m[j] = int(u) @@ -199,14 +198,14 @@ func (c *conn) pumper() { if keysym == 0 { keysym = keymap[keycode][0] } - // TODO(nigeltao): Should we send KeyboardChan ints for Shift/Ctrl/Alt? Should Shift-A send + // TODO(nigeltao): Should we send KeyEvents for Shift/Ctrl/Alt? Should Shift-A send // the same int down the channel as the sent on just the A key? // TODO(nigeltao): How should IME events (e.g. key presses that should generate CJK text) work? Or - // is that outside the scope of the draw.Context interface? + // is that outside the scope of the draw.Window interface? if c.buf[0] == 0x03 { keysym = -keysym } - c.kbd <- keysym + c.eventc <- draw.KeyEvent{keysym} case 0x04, 0x05: // Button press, button release. mask := 1 << (c.buf[1] - 1) if c.buf[0] == 0x04 { @@ -214,22 +213,21 @@ func (c *conn) pumper() { } else { c.mouseState.Buttons &^= mask } - // TODO(nigeltao): update mouseState's timestamp. - c.mouse <- c.mouseState + c.mouseState.Nsec = time.Nanoseconds() + c.eventc <- c.mouseState case 0x06: // Motion notify. - c.mouseState.Point.X = int(c.buf[25])<<8 | int(c.buf[24]) - c.mouseState.Point.Y = int(c.buf[27])<<8 | int(c.buf[26]) - // TODO(nigeltao): update mouseState's timestamp. - c.mouse <- c.mouseState + c.mouseState.Loc.X = int(int16(c.buf[25])<<8 | int16(c.buf[24])) + c.mouseState.Loc.Y = int(int16(c.buf[27])<<8 | int16(c.buf[26])) + c.mouseState.Nsec = time.Nanoseconds() + c.eventc <- c.mouseState case 0x0c: // Expose. // A single user action could trigger multiple expose events (e.g. if moving another - // window with XShape'd rounded corners over our window). In that case, the X server - // will send a count (in bytes 16-17) of the number of additional expose events coming. + // window with XShape'd rounded corners over our window). In that case, the X server will + // send a uint16 count (in bytes 16-17) of the number of additional expose events coming. // We could parse each event for the (x, y, width, height) and maintain a minimal dirty // rectangle, but for now, the simplest approach is to paint the entire window, when // receiving the final event in the series. - count := int(c.buf[17])<<8 | int(c.buf[16]) - if count == 0 { + if c.buf[17] == 0 && c.buf[16] == 0 { // TODO(nigeltao): Should we ignore the very first expose event? A freshly mapped window // will trigger expose, but until the first c.FlushImage call, there's probably nothing to // paint but black. For an 800x600 window, at 4 bytes per pixel, each repaint writes about @@ -491,16 +489,13 @@ func (c *conn) handshake() os.Error { if err != nil { return err } - // Read the vendor length. + // Read the vendor length and round it up to a multiple of 4, + // for X11 protocol alignment reasons. vendorLen, err := readU16LE(c.r, c.buf[0:2]) if err != nil { return err } - if vendorLen != 20 { - // For now, assume the vendor is "The X.Org Foundation". Supporting different - // vendors would require figuring out how much padding we need to read. - return os.NewError("unsupported X vendor") - } + vendorLen = (vendorLen + 3) &^ 3 // Read the maximum request length. maxReqLen, err := readU16LE(c.r, c.buf[0:2]) if err != nil { @@ -519,10 +514,13 @@ func (c *conn) handshake() os.Error { if err != nil { return err } - // Ignore some things that we don't care about (totalling 30 bytes): + // Ignore some things that we don't care about (totalling 10 + vendorLen bytes): // imageByteOrder(1), bitmapFormatBitOrder(1), bitmapFormatScanlineUnit(1) bitmapFormatScanlinePad(1), - // minKeycode(1), maxKeycode(1), padding(4), vendor(20, hard-coded above). - _, err = io.ReadFull(c.r, c.buf[0:30]) + // minKeycode(1), maxKeycode(1), padding(4), vendor (vendorLen). + if 10+int(vendorLen) > cap(c.buf) { + return os.NewError("unsupported X vendor") + } + _, err = io.ReadFull(c.r, c.buf[0:10+int(vendorLen)]) if err != nil { return err } @@ -550,7 +548,7 @@ func (c *conn) handshake() os.Error { } // NewWindow calls NewWindowDisplay with $DISPLAY. -func NewWindow() (draw.Context, os.Error) { +func NewWindow() (draw.Window, os.Error) { display := os.Getenv("DISPLAY") if len(display) == 0 { return nil, os.NewError("$DISPLAY not set") @@ -558,10 +556,10 @@ func NewWindow() (draw.Context, os.Error) { return NewWindowDisplay(display) } -// NewWindowDisplay returns a new draw.Context, backed by a newly created and +// NewWindowDisplay returns a new draw.Window, backed by a newly created and // mapped X11 window. The X server to connect to is specified by the display // string, such as ":1". -func NewWindowDisplay(display string) (draw.Context, os.Error) { +func NewWindowDisplay(display string) (draw.Window, os.Error) { socket, displayStr, err := connect(display) if err != nil { return nil, err @@ -616,13 +614,9 @@ func NewWindowDisplay(display string) (draw.Context, os.Error) { } c.img = image.NewRGBA(windowWidth, windowHeight) - // TODO(nigeltao): Should these channels be buffered? - c.kbd = make(chan int) - c.mouse = make(chan draw.Mouse) - c.resize = make(chan bool) - c.quit = make(chan bool) + c.eventc = make(chan interface{}, 16) c.flush = make(chan bool, 1) - go c.flusher() - go c.pumper() + go c.readSocket() + go c.writeSocket() return c, nil } diff --git a/src/pkg/exp/eval/Makefile b/src/pkg/exp/eval/Makefile index eac844f1e..2b716b14c 100644 --- a/src/pkg/exp/eval/Makefile +++ b/src/pkg/exp/eval/Makefile @@ -2,7 +2,7 @@ # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. -include ../../../Make.$(GOARCH) +include ../../../Make.inc TARG=exp/eval GOFILES=\ @@ -16,14 +16,22 @@ GOFILES=\ stmt.go\ type.go\ typec.go\ - util.go\ value.go\ world.go\ include ../../../Make.pkg main.$O: main.go $(pkgdir)/$(TARG).a - $(QUOTED_GOBIN)/$(GC) $< + $(GC) $< eval: main.$O - $(QUOTED_GOBIN)/$(LD) -o $@ $< + $(LD) -o $@ $< + +gen.$O: gen.go + $(GC) $< + +generate: gen.$O $(pkgdir)/$(TARG).a + $(LD) -o $@ $<;\ + ./generate > expr1.go;\ + gofmt -w expr1.go + diff --git a/src/pkg/exp/eval/bridge.go b/src/pkg/exp/eval/bridge.go index c53febc8a..3fa498d68 100644 --- a/src/pkg/exp/eval/bridge.go +++ b/src/pkg/exp/eval/bridge.go @@ -29,7 +29,7 @@ func TypeFromNative(t reflect.Type) Type { var nt *NamedType if t.Name() != "" { name := t.PkgPath() + "·" + t.Name() - nt = &NamedType{token.Position{}, name, nil, true, make(map[string]Method)} + nt = &NamedType{token.NoPos, name, nil, true, make(map[string]Method)} evalTypes[t] = nt } @@ -79,7 +79,7 @@ func TypeFromNative(t reflect.Type) Type { case *reflect.ArrayType: et = NewArrayType(int64(t.Len()), TypeFromNative(t.Elem())) case *reflect.ChanType: - log.Crashf("%T not implemented", t) + log.Panicf("%T not implemented", t) case *reflect.FuncType: nin := t.NumIn() // Variadic functions have DotDotDotType at the end @@ -97,9 +97,9 @@ func TypeFromNative(t reflect.Type) Type { } et = NewFuncType(in, variadic, out) case *reflect.InterfaceType: - log.Crashf("%T not implemented", t) + log.Panicf("%T not implemented", t) case *reflect.MapType: - log.Crashf("%T not implemented", t) + log.Panicf("%T not implemented", t) case *reflect.PtrType: et = NewPtrType(TypeFromNative(t.Elem())) case *reflect.SliceType: @@ -116,9 +116,9 @@ func TypeFromNative(t reflect.Type) Type { } et = NewStructType(fields) case *reflect.UnsafePointerType: - log.Crashf("%T not implemented", t) + log.Panicf("%T not implemented", t) default: - log.Crashf("unexpected reflect.Type: %T", t) + log.Panicf("unexpected reflect.Type: %T", t) } if nt != nil { diff --git a/src/pkg/exp/eval/compiler.go b/src/pkg/exp/eval/compiler.go index 3e37bfbaa..9d2923bfc 100644 --- a/src/pkg/exp/eval/compiler.go +++ b/src/pkg/exp/eval/compiler.go @@ -11,24 +11,20 @@ import ( ) -type positioned interface { - Pos() token.Position -} - - // A compiler captures information used throughout an entire // compilation. Currently it includes only the error handler. // // TODO(austin) This might actually represent package level, in which // case it should be package compiler. type compiler struct { + fset *token.FileSet errors scanner.ErrorHandler numErrors int silentErrors int } -func (a *compiler) diagAt(pos positioned, format string, args ...interface{}) { - a.errors.Error(pos.Pos(), fmt.Sprintf(format, args)) +func (a *compiler) diagAt(pos token.Pos, format string, args ...interface{}) { + a.errors.Error(a.fset.Position(pos), fmt.Sprintf(format, args...)) a.numErrors++ } @@ -64,9 +60,9 @@ type label struct { continuePC *uint // The position where this label was resolved. If it has not // been resolved yet, an invalid position. - resolved token.Position + resolved token.Pos // The position where this label was first jumped to. - used token.Position + used token.Pos } // A funcCompiler captures information used throughout the compilation diff --git a/src/pkg/exp/eval/eval_test.go b/src/pkg/exp/eval/eval_test.go index 1dfdfe1fd..6bfe9089d 100644 --- a/src/pkg/exp/eval/eval_test.go +++ b/src/pkg/exp/eval/eval_test.go @@ -5,15 +5,20 @@ package eval import ( - "exp/bignum" + "big" "flag" "fmt" + "go/token" "log" "os" "reflect" + "regexp" "testing" ) +// All tests are done using the same file set. +var fset = token.NewFileSet() + // Print each statement or expression before parsing it var noisy = false @@ -48,7 +53,7 @@ func (a test) run(t *testing.T, name string) { println("code:", src) } - code, err := w.Compile(src) + code, err := w.Compile(fset, src) if err != nil { if j.cerr == "" { t.Errorf("%s: Compile %s: %v", name, src, err) @@ -89,9 +94,9 @@ func (a test) run(t *testing.T, name string) { } func match(t *testing.T, err os.Error, pat string) bool { - ok, errstr := testing.MatchString(pat, err.String()) - if errstr != "" { - t.Fatalf("compile regexp %s: %v", pat, errstr) + ok, err1 := regexp.MatchString(pat, err.String()) + if err1 != nil { + t.Fatalf("compile regexp %s: %v", pat, err1) } return ok } @@ -102,40 +107,40 @@ func match(t *testing.T, err os.Error, pat string) bool { */ // Expression compile error -func CErr(expr string, cerr string) test { return test([]job{job{code: expr, cerr: cerr}}) } +func CErr(expr string, cerr string) test { return test([]job{{code: expr, cerr: cerr}}) } // Expression runtime error -func RErr(expr string, rterr string) test { return test([]job{job{code: expr, rterr: rterr}}) } +func RErr(expr string, rterr string) test { return test([]job{{code: expr, rterr: rterr}}) } // Expression value func Val(expr string, val interface{}) test { - return test([]job{job{code: expr, val: toValue(val)}}) + return test([]job{{code: expr, val: toValue(val)}}) } // Statement runs without error -func Run(stmts string) test { return test([]job{job{code: stmts, noval: true}}) } +func Run(stmts string) test { return test([]job{{code: stmts, noval: true}}) } // Two statements without error. // TODO(rsc): Should be possible with Run but the parser // won't let us do both top-level and non-top-level statements. func Run2(stmt1, stmt2 string) test { - return test([]job{job{code: stmt1, noval: true}, job{code: stmt2, noval: true}}) + return test([]job{{code: stmt1, noval: true}, {code: stmt2, noval: true}}) } // Statement runs and test one expression's value func Val1(stmts string, expr1 string, val1 interface{}) test { return test([]job{ - job{code: stmts, noval: true}, - job{code: expr1, val: toValue(val1)}, + {code: stmts, noval: true}, + {code: expr1, val: toValue(val1)}, }) } // Statement runs and test two expressions' values func Val2(stmts string, expr1 string, val1 interface{}, expr2 string, val2 interface{}) test { return test([]job{ - job{code: stmts, noval: true}, - job{code: expr1, val: toValue(val1)}, - job{code: expr2, val: toValue(val2)}, + {code: stmts, noval: true}, + {code: expr1, val: toValue(val1)}, + {code: expr2, val: toValue(val2)}, }) } @@ -166,12 +171,12 @@ func toValue(val interface{}) Value { case int: r := intV(val) return &r - case *bignum.Integer: + case *big.Int: return &idealIntV{val} case float: r := floatV(val) return &r - case *bignum.Rational: + case *big.Rat: return &idealFloatV{val} case string: r := stringV(val) @@ -195,7 +200,7 @@ func toValue(val interface{}) Value { case Func: return &funcV{val} } - log.Crashf("toValue(%T) not implemented", val) + log.Panicf("toValue(%T) not implemented", val) panic("unreachable") } @@ -205,7 +210,7 @@ func toValue(val interface{}) Value { type testFunc struct{} -func (*testFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } +func (*testFunc) NewFrame() *Frame { return &Frame{nil, make([]Value, 2)} } func (*testFunc) Call(t *Thread) { n := t.f.Vars[0].(IntValue).Get(t) @@ -217,7 +222,7 @@ func (*testFunc) Call(t *Thread) { type oneTwoFunc struct{} -func (*oneTwoFunc) NewFrame() *Frame { return &Frame{nil, &[2]Value{}} } +func (*oneTwoFunc) NewFrame() *Frame { return &Frame{nil, make([]Value, 2)} } func (*oneTwoFunc) Call(t *Thread) { t.f.Vars[0].(IntValue).Set(t, 1) @@ -235,13 +240,13 @@ func newTestWorld() *World { def := func(name string, t Type, val interface{}) { w.DefineVar(name, t, toValue(val)) } - w.DefineConst("c", IdealIntType, toValue(bignum.Int(1))) + w.DefineConst("c", IdealIntType, toValue(big.NewInt(1))) def("i", IntType, 1) def("i2", IntType, 2) def("u", UintType, uint(1)) def("f", FloatType, 1.0) def("s", StringType, "abc") - def("t", NewStructType([]StructField{StructField{"a", IntType, false}}), vstruct{1}) + def("t", NewStructType([]StructField{{"a", IntType, false}}), vstruct{1}) def("ai", NewArrayType(2, IntType), varray{1, 2}) def("aai", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{1, 2}, varray{3, 4}}) def("aai2", NewArrayType(2, NewArrayType(2, IntType)), varray{varray{5, 6}, varray{7, 8}}) diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go index ea8117d06..70f63cf2d 100644 --- a/src/pkg/exp/eval/expr.go +++ b/src/pkg/exp/eval/expr.go @@ -5,7 +5,7 @@ package eval import ( - "exp/bignum" + "big" "fmt" "go/ast" "go/token" @@ -15,6 +15,11 @@ import ( "os" ) +var ( + idealZero = big.NewInt(0) + idealOne = big.NewInt(1) +) + // An expr is the result of compiling an expression. It stores the // type of the expression and its evaluator function. type expr struct { @@ -52,7 +57,7 @@ type expr struct { // compiled from it. type exprInfo struct { *compiler - pos token.Position + pos token.Pos } func (a *exprInfo) newExpr(t Type, desc string) *expr { @@ -60,7 +65,7 @@ func (a *exprInfo) newExpr(t Type, desc string) *expr { } func (a *exprInfo) diag(format string, args ...interface{}) { - a.diagAt(&a.pos, format, args) + a.diagAt(a.pos, format, args...) } func (a *exprInfo) diagOpType(op token.Token, vt Type) { @@ -82,10 +87,10 @@ func (a *exprInfo) diagOpTypes(op token.Token, lt Type, rt Type) { // TODO(austin) Rename to resolveIdeal or something? func (a *expr) convertTo(t Type) *expr { if !a.t.isIdeal() { - log.Crashf("attempted to convert from %v, expected ideal", a.t) + log.Panicf("attempted to convert from %v, expected ideal", a.t) } - var rat *bignum.Rational + var rat *big.Rat // XXX(Spec) The spec says "It is erroneous". // @@ -97,24 +102,24 @@ func (a *expr) convertTo(t Type) *expr { case IdealFloatType: rat = a.asIdealFloat()() if t.isInteger() && !rat.IsInt() { - a.diag("constant %v truncated to integer", ratToString(rat)) + a.diag("constant %v truncated to integer", rat.FloatString(6)) return nil } case IdealIntType: i := a.asIdealInt()() - rat = bignum.MakeRat(i, bignum.Nat(1)) + rat = new(big.Rat).SetInt(i) default: - log.Crashf("unexpected ideal type %v", a.t) + log.Panicf("unexpected ideal type %v", a.t) } // Check bounds if t, ok := t.lit().(BoundedType); ok { if rat.Cmp(t.minVal()) < 0 { - a.diag("constant %v underflows %v", ratToString(rat), t) + a.diag("constant %v underflows %v", rat.FloatString(6), t) return nil } if rat.Cmp(t.maxVal()) > 0 { - a.diag("constant %v overflows %v", ratToString(rat), t) + a.diag("constant %v overflows %v", rat.FloatString(6), t) return nil } } @@ -123,27 +128,28 @@ func (a *expr) convertTo(t Type) *expr { res := a.newExpr(t, a.desc) switch t := t.lit().(type) { case *uintType: - n, d := rat.Value() - f := n.Quo(bignum.MakeInt(false, d)) - v := f.Abs().Value() + n, d := rat.Num(), rat.Denom() + f := new(big.Int).Quo(n, d) + f = f.Abs(f) + v := uint64(f.Int64()) res.eval = func(*Thread) uint64 { return v } case *intType: - n, d := rat.Value() - f := n.Quo(bignum.MakeInt(false, d)) - v := f.Value() + n, d := rat.Num(), rat.Denom() + f := new(big.Int).Quo(n, d) + v := f.Int64() res.eval = func(*Thread) int64 { return v } case *idealIntType: - n, d := rat.Value() - f := n.Quo(bignum.MakeInt(false, d)) - res.eval = func() *bignum.Integer { return f } + n, d := rat.Num(), rat.Denom() + f := new(big.Int).Quo(n, d) + res.eval = func() *big.Int { return f } case *floatType: - n, d := rat.Value() - v := float64(n.Value()) / float64(d.Value()) + n, d := rat.Num(), rat.Denom() + v := float64(n.Int64()) / float64(d.Int64()) res.eval = func(*Thread) float64 { return v } case *idealFloatType: - res.eval = func() *bignum.Rational { return rat } + res.eval = func() *big.Rat { return rat } default: - log.Crashf("cannot convert to type %T", t) + log.Panicf("cannot convert to type %T", t) } return res @@ -158,7 +164,7 @@ func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr { switch a.t.lit().(type) { case *idealIntType: val := a.asIdealInt()() - if negErr != "" && val.IsNeg() { + if negErr != "" && val.Sign() < 0 { a.diag("negative %s: %s", negErr, val) return nil } @@ -166,7 +172,7 @@ func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr { if negErr == "slice" { bound++ } - if max != -1 && val.Cmp(bignum.Int(bound)) >= 0 { + if max != -1 && val.Cmp(big.NewInt(bound)) >= 0 { a.diag("index %s exceeds length %d", val, max) return nil } @@ -196,7 +202,7 @@ func (a *expr) derefArray() *expr { if _, ok := pt.Elem.lit().(*ArrayType); ok { deref := a.compileStarExpr(a) if deref == nil { - log.Crashf("failed to dereference *array") + log.Panicf("failed to dereference *array") } return deref } @@ -223,7 +229,7 @@ func (a *expr) derefArray() *expr { // multi-valued type. type assignCompiler struct { *compiler - pos token.Position + pos token.Pos // The RHS expressions. This may include nil's for // expressions that failed to compile. rs []*expr @@ -248,7 +254,7 @@ type assignCompiler struct { // assignCompiler with rmt set, but if type checking fails, slots in // the MultiType may be nil. If rs contains nil's, type checking will // fail and these expressions given a nil type. -func (a *compiler) checkAssign(pos token.Position, rs []*expr, errOp, errPosName string) (*assignCompiler, bool) { +func (a *compiler) checkAssign(pos token.Pos, rs []*expr, errOp, errPosName string) (*assignCompiler, bool) { c := &assignCompiler{ compiler: a, pos: pos, @@ -325,7 +331,7 @@ func (a *assignCompiler) compile(b *block, lt Type) func(Value, *Thread) { pos = a.rs[lcount-1].pos } } - a.diagAt(&pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt) + a.diagAt(pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt) return nil } @@ -364,7 +370,7 @@ func (a *assignCompiler) compile(b *block, lt Type) func(Value, *Thread) { a.rs = make([]*expr, len(a.rmt.Elems)) for i, t := range a.rmt.Elems { if t.isIdeal() { - log.Crashf("Right side of unpack contains ideal: %s", rmt) + log.Panicf("Right side of unpack contains ideal: %s", rmt) } a.rs[i] = orig.newExpr(t, orig.desc) index := i @@ -447,7 +453,7 @@ func (a *assignCompiler) compile(b *block, lt Type) func(Value, *Thread) { // compileAssign compiles an assignment operation without the full // generality of an assignCompiler. See assignCompiler for a // description of the arguments. -func (a *compiler) compileAssign(pos token.Position, b *block, lt Type, rs []*expr, errOp, errPosName string) func(Value, *Thread) { +func (a *compiler) compileAssign(pos token.Pos, b *block, lt Type, rs []*expr, errOp, errPosName string) func(Value, *Thread) { ac, ok := a.checkAssign(pos, rs, errOp, errPosName) if !ok { return nil @@ -490,7 +496,7 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { case token.STRING: return ei.compileStringLit(string(x.Value)) default: - log.Crashf("unexpected basic literal type %v", x.Kind) + log.Panicf("unexpected basic literal type %v", x.Kind) } case *ast.CompositeLit: @@ -508,7 +514,7 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return nil } if a.constant { - a.diagAt(x, "function literal used in constant expression") + a.diagAt(x.Pos(), "function literal used in constant expression") return nil } return ei.compileFuncLit(decl, fn) @@ -565,12 +571,12 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return nil } if a.constant { - a.diagAt(x, "function call in constant context") + a.diagAt(x.Pos(), "function call in constant context") return nil } if l.valType != nil { - a.diagAt(x, "type conversions not implemented") + a.diagAt(x.Pos(), "type conversions not implemented") return nil } else if ft, ok := l.t.(*FuncType); ok && ft.builtin != "" { return ei.compileBuiltinCallExpr(a.block, ft, args) @@ -579,7 +585,7 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { } case *ast.Ident: - return ei.compileIdent(a.block, a.constant, callCtx, x.Name()) + return ei.compileIdent(a.block, a.constant, callCtx, x.Name) case *ast.IndexExpr: l, r := a.compile(x.X, false), a.compile(x.Index, false) @@ -589,15 +595,21 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { return ei.compileIndexExpr(l, r) case *ast.SliceExpr: - var hi *expr + var lo, hi *expr arr := a.compile(x.X, false) - lo := a.compile(x.Index, false) - if x.End == nil { + if x.Low == nil { + // beginning was omitted, so we need to provide it + ei := &exprInfo{a.compiler, x.Pos()} + lo = ei.compileIntLit("0") + } else { + lo = a.compile(x.Low, false) + } + if x.High == nil { // End was omitted, so we need to compute len(x.X) ei := &exprInfo{a.compiler, x.Pos()} hi = ei.compileBuiltinCallExpr(a.block, lenType, []*expr{arr}) } else { - hi = a.compile(x.End, false) + hi = a.compile(x.High, false) } if arr == nil || lo == nil || hi == nil { return nil @@ -615,7 +627,7 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { if v == nil { return nil } - return ei.compileSelectorExpr(v, x.Sel.Name()) + return ei.compileSelectorExpr(v, x.Sel.Name) case *ast.StarExpr: // We pass down our call context because this could be @@ -643,18 +655,18 @@ func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr { } return ei.compileUnaryExpr(x.Op, v) } - log.Crashf("unexpected ast node type %T", x) + log.Panicf("unexpected ast node type %T", x) panic("unreachable") typeexpr: if !callCtx { - a.diagAt(x, "type used as expression") + a.diagAt(x.Pos(), "type used as expression") return nil } return ei.exprFromType(a.compileType(a.block, x)) notimpl: - a.diagAt(x, "%T expression node not implemented", x) + a.diagAt(x.Pos(), "%T expression node not implemented", x) return nil } @@ -705,7 +717,7 @@ func (a *exprInfo) compileIdent(b *block, constant bool, callCtx bool, name stri a.diag("type %v used as expression", name) return nil } - log.Crashf("name %s has unknown type %T", name, def) + log.Panicf("name %s has unknown type %T", name, def) panic("unreachable") } @@ -735,14 +747,14 @@ func (a *exprInfo) compileGlobalVariable(v *Variable) *expr { return expr } -func (a *exprInfo) compileIdealInt(i *bignum.Integer, desc string) *expr { +func (a *exprInfo) compileIdealInt(i *big.Int, desc string) *expr { expr := a.newExpr(IdealIntType, desc) - expr.eval = func() *bignum.Integer { return i } + expr.eval = func() *big.Int { return i } return expr } func (a *exprInfo) compileIntLit(lit string) *expr { - i, _, _ := bignum.IntFromString(lit, 0) + i, _ := new(big.Int).SetString(lit, 0) return a.compileIdealInt(i, "integer literal") } @@ -758,16 +770,16 @@ func (a *exprInfo) compileCharLit(lit string) *expr { a.silentErrors++ return nil } - return a.compileIdealInt(bignum.Int(int64(v)), "character literal") + return a.compileIdealInt(big.NewInt(int64(v)), "character literal") } func (a *exprInfo) compileFloatLit(lit string) *expr { - f, _, n := bignum.RatFromString(lit, 10) - if n != len(lit) { - log.Crashf("malformed float literal %s at %v passed parser", lit, a.pos) + f, ok := new(big.Rat).SetString(lit) + if !ok { + log.Panicf("malformed float literal %s at %v passed parser", lit, a.pos) } expr := a.newExpr(IdealFloatType, "float literal") - expr.eval = func() *bignum.Rational { return f } + expr.eval = func() *big.Rat { return f } return expr } @@ -822,7 +834,7 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { ambig = true default: - log.Crashf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth) + log.Panicf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth) } amberr += "\n\t" + pathName[1:] } @@ -864,7 +876,7 @@ func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr { _, ok := ti.methods[name] if ok { mark(depth, pathName+"."+name) - log.Crash("Methods not implemented") + log.Panic("Methods not implemented") } t = ti.Def } @@ -996,7 +1008,7 @@ func (a *exprInfo) compileSliceExpr(arr, lo, hi *expr) *expr { } default: - log.Crashf("unexpected left operand type %T", arr.t.lit()) + log.Panicf("unexpected left operand type %T", arr.t.lit()) } return expr @@ -1120,7 +1132,7 @@ func (a *exprInfo) compileIndexExpr(l, r *expr) *expr { } default: - log.Crashf("unexpected left operand type %T", l.t.lit()) + log.Panicf("unexpected left operand type %T", l.t.lit()) } return expr @@ -1168,12 +1180,8 @@ func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr { // Gather argument and out types to initialize frame variables vts := make([]Type, nin+nout) - for i, t := range lt.In { - vts[i] = t - } - for i, t := range lt.Out { - vts[i+nin] = t - } + copy(vts, lt.In) + copy(vts[nin:], lt.Out) // Compile lf := l.asFunc() @@ -1233,6 +1241,38 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e } return expr + case copyType: + if !checkCount(2, 2) { + return nil + } + src := as[1] + dst := as[0] + if src.t != dst.t { + a.diag("arguments to built-in function 'copy' must have same type\nsrc: %s\ndst: %s\n", src.t, dst.t) + return nil + } + if _, ok := src.t.lit().(*SliceType); !ok { + a.diag("src argument to 'copy' must be a slice (got: %s)", src.t) + return nil + } + if _, ok := dst.t.lit().(*SliceType); !ok { + a.diag("dst argument to 'copy' must be a slice (got: %s)", dst.t) + return nil + } + expr := a.newExpr(IntType, "function call") + srcf := src.asSlice() + dstf := dst.asSlice() + expr.eval = func(t *Thread) int64 { + src, dst := srcf(t), dstf(t) + nelems := src.Len + if nelems > dst.Len { + nelems = dst.Len + } + dst.Base.Sub(0, nelems).Assign(t, src.Base.Sub(0, nelems)) + return nelems + } + return expr + case lenType: if !checkCount(1, 1) { return nil @@ -1425,7 +1465,7 @@ func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *e return expr } - log.Crashf("unexpected built-in function '%s'", ft.builtin) + log.Panicf("unexpected built-in function '%s'", ft.builtin) panic("unreachable") } @@ -1492,10 +1532,10 @@ func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { t = NewPtrType(v.t) case token.ARROW: - log.Crashf("Unary op %v not implemented", op) + log.Panicf("Unary op %v not implemented", op) default: - log.Crashf("unknown unary operator %v", op) + log.Panicf("unknown unary operator %v", op) } desc, ok := unaryOpDescs[op] @@ -1526,7 +1566,7 @@ func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr { expr.eval = func(t *Thread) Value { return vf(t) } default: - log.Crashf("Compilation of unary op %v not implemented", op) + log.Panicf("Compilation of unary op %v not implemented", op) } return expr @@ -1650,7 +1690,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { if l.t.isIdeal() && !r.t.isInteger() { r = r.convertTo(IdealIntType) if r == nil { - log.Crashf("conversion to uintType succeeded, but conversion to idealIntType failed") + log.Panicf("conversion to uintType succeeded, but conversion to idealIntType failed") } } } else if _, ok := r.t.lit().(*uintType); !ok { @@ -1693,7 +1733,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { // The operands in channel sends differ in type: one // is always a channel and the other is a variable or // value of the channel's element type. - log.Crash("Binary op <- not implemented") + log.Panic("Binary op <- not implemented") t = BoolType case token.LSS, token.GTR, token.LEQ, token.GEQ: @@ -1761,7 +1801,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { t = BoolType default: - log.Crashf("unknown binary operator %v", op) + log.Panicf("unknown binary operator %v", op) } desc, ok := binOpDescs[op] @@ -1774,8 +1814,8 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { switch op { case token.QUO, token.REM: if r.t.isIdeal() { - if (r.t.isInteger() && r.asIdealInt()().IsZero()) || - (r.t.isFloat() && r.asIdealFloat()().IsZero()) { + if (r.t.isInteger() && r.asIdealInt()().Sign() == 0) || + (r.t.isFloat() && r.asIdealFloat()().Sign() == 0) { a.diag("divide by zero") return nil } @@ -1817,13 +1857,13 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { lv := l.asIdealInt()() rv := r.asIdealInt()() const maxShift = 99999 - if rv.Cmp(bignum.Int(maxShift)) > 0 { + if rv.Cmp(big.NewInt(maxShift)) > 0 { a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift) expr.t = nil return nil } - val := lv.Shl(uint(rv.Value())) - expr.eval = func() *bignum.Integer { return val } + val := new(big.Int).Lsh(lv, uint(rv.Int64())) + expr.eval = func() *big.Int { return val } } else { expr.genBinOpShl(l, r) } @@ -1832,8 +1872,8 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { if l.t.isIdeal() { lv := l.asIdealInt()() rv := r.asIdealInt()() - val := lv.Shr(uint(rv.Value())) - expr.eval = func() *bignum.Integer { return val } + val := new(big.Int).Rsh(lv, uint(rv.Int64())) + expr.eval = func() *big.Int { return val } } else { expr.genBinOpShr(l, r) } @@ -1863,7 +1903,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr { expr.genBinOpLogOr(l, r) default: - log.Crashf("Compilation of binary op %v not implemented", op) + log.Panicf("Compilation of binary op %v not implemented", op) } return expr @@ -1886,7 +1926,7 @@ func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) { } if !lenExpr.t.isInteger() { - a.diagAt(expr, "array size must be an integer") + a.diagAt(expr.Pos(), "array size must be an integer") return 0, false } @@ -1896,7 +1936,7 @@ func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) { case *uintType: return int64(lenExpr.asUint()(nil)), true } - log.Crashf("unexpected integer type %T", lenExpr.t) + log.Panicf("unexpected integer type %T", lenExpr.t) return 0, false } @@ -1905,7 +1945,7 @@ func (a *compiler) compileExpr(b *block, constant bool, expr ast.Expr) *expr { nerr := a.numError() e := ec.compile(expr, false) if e == nil && nerr == a.numError() { - log.Crashf("expression compilation failed without reporting errors") + log.Panicf("expression compilation failed without reporting errors") } return e } @@ -1943,7 +1983,7 @@ func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) { case tempType.isFloat(): tempType = FloatType default: - log.Crashf("unexpected ideal type %v", tempType) + log.Panicf("unexpected ideal type %v", tempType) } } temp := b.DefineTemp(tempType) @@ -1952,7 +1992,7 @@ func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) { // Create "temp := rhs" assign := ac.compile(b, tempType) if assign == nil { - log.Crashf("compileAssign type check failed") + log.Panicf("compileAssign type check failed") } effect := func(t *Thread) { diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go index f0a78ac4d..ae0cfc723 100644..100755 --- a/src/pkg/exp/eval/expr1.go +++ b/src/pkg/exp/eval/expr1.go @@ -4,13 +4,13 @@ package eval import ( - "exp/bignum" + "big" "log" ) /* - * "As" functions. These retrieve evaluator functions from an - * expr, panicking if the requested evaluator has the wrong type. +* "As" functions. These retrieve evaluator functions from an +* expr, panicking if the requested evaluator has the wrong type. */ func (a *expr) asBool() func(*Thread) bool { return a.eval.(func(*Thread) bool) @@ -21,14 +21,14 @@ func (a *expr) asUint() func(*Thread) uint64 { func (a *expr) asInt() func(*Thread) int64 { return a.eval.(func(*Thread) int64) } -func (a *expr) asIdealInt() func() *bignum.Integer { - return a.eval.(func() *bignum.Integer) +func (a *expr) asIdealInt() func() *big.Int { + return a.eval.(func() *big.Int) } func (a *expr) asFloat() func(*Thread) float64 { return a.eval.(func(*Thread) float64) } -func (a *expr) asIdealFloat() func() *bignum.Rational { - return a.eval.(func() *bignum.Rational) +func (a *expr) asIdealFloat() func() *big.Rat { + return a.eval.(func() *big.Rat) } func (a *expr) asString() func(*Thread) string { return a.eval.(func(*Thread) string) @@ -63,11 +63,11 @@ func (a *expr) asInterface() func(*Thread) interface{} { return func(t *Thread) interface{} { return sf(t) } case func(t *Thread) int64: return func(t *Thread) interface{} { return sf(t) } - case func() *bignum.Integer: + case func() *big.Int: return func(*Thread) interface{} { return sf() } case func(t *Thread) float64: return func(t *Thread) interface{} { return sf(t) } - case func() *bignum.Rational: + case func() *big.Rat: return func(*Thread) interface{} { return sf() } case func(t *Thread) string: return func(t *Thread) interface{} { return sf(t) } @@ -84,13 +84,13 @@ func (a *expr) asInterface() func(*Thread) interface{} { case func(t *Thread) Map: return func(t *Thread) interface{} { return sf(t) } default: - log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos) + log.Panicf("unexpected expression node type %T at %v", a.eval, a.pos) } panic("fail") } /* - * Operator generators. +* Operator generators. */ func (a *expr) genConstant(v Value) { @@ -103,12 +103,12 @@ func (a *expr) genConstant(v Value) { a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) } case *idealIntType: val := v.(IdealIntValue).Get() - a.eval = func() *bignum.Integer { return val } + a.eval = func() *big.Int { return val } case *floatType: a.eval = func(t *Thread) float64 { return v.(FloatValue).Get(t) } case *idealFloatType: val := v.(IdealFloatValue).Get() - a.eval = func() *bignum.Rational { return val } + a.eval = func() *big.Rat { return val } case *stringType: a.eval = func(t *Thread) string { return v.(StringValue).Get(t) } case *ArrayType: @@ -124,7 +124,7 @@ func (a *expr) genConstant(v Value) { case *MapType: a.eval = func(t *Thread) Map { return v.(MapValue).Get(t) } default: - log.Crashf("unexpected constant type %v at %v", a.t, a.pos) + log.Panicf("unexpected constant type %v at %v", a.t, a.pos) } } @@ -154,7 +154,7 @@ func (a *expr) genIdentOp(level, index int) { case *MapType: a.eval = func(t *Thread) Map { return t.f.Get(level, index).(MapValue).Get(t) } default: - log.Crashf("unexpected identifier type %v at %v", a.t, a.pos) + log.Panicf("unexpected identifier type %v at %v", a.t, a.pos) } } @@ -186,7 +186,7 @@ func (a *expr) genFuncCall(call func(t *Thread) []Value) { case *MultiType: a.eval = func(t *Thread) []Value { return call(t) } default: - log.Crashf("unexpected result type %v at %v", a.t, a.pos) + log.Panicf("unexpected result type %v at %v", a.t, a.pos) } } @@ -216,7 +216,7 @@ func (a *expr) genValue(vf func(*Thread) Value) { case *MapType: a.eval = func(t *Thread) Map { return vf(t).(MapValue).Get(t) } default: - log.Crashf("unexpected result type %v at %v", a.t, a.pos) + log.Panicf("unexpected result type %v at %v", a.t, a.pos) } } @@ -229,18 +229,18 @@ func (a *expr) genUnaryOpNeg(v *expr) { vf := v.asInt() a.eval = func(t *Thread) int64 { v := vf(t); return -v } case *idealIntType: - v := v.asIdealInt()() - val := v.Neg() - a.eval = func() *bignum.Integer { return val } + val := v.asIdealInt()() + val.Neg(val) + a.eval = func() *big.Int { return val } case *floatType: vf := v.asFloat() a.eval = func(t *Thread) float64 { v := vf(t); return -v } case *idealFloatType: - v := v.asIdealFloat()() - val := v.Neg() - a.eval = func() *bignum.Rational { return val } + val := v.asIdealFloat()() + val.Neg(val) + a.eval = func() *big.Rat { return val } default: - log.Crashf("unexpected type %v at %v", a.t, a.pos) + log.Panicf("unexpected type %v at %v", a.t, a.pos) } } @@ -250,7 +250,7 @@ func (a *expr) genUnaryOpNot(v *expr) { vf := v.asBool() a.eval = func(t *Thread) bool { v := vf(t); return !v } default: - log.Crashf("unexpected type %v at %v", a.t, a.pos) + log.Panicf("unexpected type %v at %v", a.t, a.pos) } } @@ -263,11 +263,11 @@ func (a *expr) genUnaryOpXor(v *expr) { vf := v.asInt() a.eval = func(t *Thread) int64 { v := vf(t); return ^v } case *idealIntType: - v := v.asIdealInt()() - val := v.Neg().Sub(bignum.Int(1)) - a.eval = func() *bignum.Integer { return val } + val := v.asIdealInt()() + val.Not(val) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", a.t, a.pos) + log.Panicf("unexpected type %v at %v", a.t, a.pos) } } @@ -325,7 +325,7 @@ func (a *expr) genBinOpAdd(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -367,13 +367,13 @@ func (a *expr) genBinOpAdd(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Add(r) - a.eval = func() *bignum.Integer { return val } + val := l.Add(l, r) + a.eval = func() *big.Int { return val } case *floatType: lf := l.asFloat() rf := r.asFloat() @@ -400,13 +400,13 @@ func (a *expr) genBinOpAdd(l, r *expr) { return float64(float(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: l := l.asIdealFloat()() r := r.asIdealFloat()() - val := l.Add(r) - a.eval = func() *bignum.Rational { return val } + val := l.Add(l, r) + a.eval = func() *big.Rat { return val } case *stringType: lf := l.asString() rf := r.asString() @@ -415,7 +415,7 @@ func (a *expr) genBinOpAdd(l, r *expr) { return l + r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -461,7 +461,7 @@ func (a *expr) genBinOpSub(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -503,13 +503,13 @@ func (a *expr) genBinOpSub(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Sub(r) - a.eval = func() *bignum.Integer { return val } + val := l.Sub(l, r) + a.eval = func() *big.Int { return val } case *floatType: lf := l.asFloat() rf := r.asFloat() @@ -536,15 +536,15 @@ func (a *expr) genBinOpSub(l, r *expr) { return float64(float(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: l := l.asIdealFloat()() r := r.asIdealFloat()() - val := l.Sub(r) - a.eval = func() *bignum.Rational { return val } + val := l.Sub(l, r) + a.eval = func() *big.Rat { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -590,7 +590,7 @@ func (a *expr) genBinOpMul(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -632,13 +632,13 @@ func (a *expr) genBinOpMul(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Mul(r) - a.eval = func() *bignum.Integer { return val } + val := l.Mul(l, r) + a.eval = func() *big.Int { return val } case *floatType: lf := l.asFloat() rf := r.asFloat() @@ -665,15 +665,15 @@ func (a *expr) genBinOpMul(l, r *expr) { return float64(float(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: l := l.asIdealFloat()() r := r.asIdealFloat()() - val := l.Mul(r) - a.eval = func() *bignum.Rational { return val } + val := l.Mul(l, r) + a.eval = func() *big.Rat { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -734,7 +734,7 @@ func (a *expr) genBinOpQuo(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -791,13 +791,13 @@ func (a *expr) genBinOpQuo(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Quo(r) - a.eval = func() *bignum.Integer { return val } + val := l.Quo(l, r) + a.eval = func() *big.Int { return val } case *floatType: lf := l.asFloat() rf := r.asFloat() @@ -833,15 +833,15 @@ func (a *expr) genBinOpQuo(l, r *expr) { return float64(float(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealFloatType: l := l.asIdealFloat()() r := r.asIdealFloat()() - val := l.Quo(r) - a.eval = func() *bignum.Rational { return val } + val := l.Quo(l, r) + a.eval = func() *big.Rat { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -902,7 +902,7 @@ func (a *expr) genBinOpRem(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -959,15 +959,15 @@ func (a *expr) genBinOpRem(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Rem(r) - a.eval = func() *bignum.Integer { return val } + val := l.Rem(l, r) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1013,7 +1013,7 @@ func (a *expr) genBinOpAnd(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1055,15 +1055,15 @@ func (a *expr) genBinOpAnd(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.And(r) - a.eval = func() *bignum.Integer { return val } + val := l.And(l, r) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1109,7 +1109,7 @@ func (a *expr) genBinOpOr(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1151,15 +1151,15 @@ func (a *expr) genBinOpOr(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Or(r) - a.eval = func() *bignum.Integer { return val } + val := l.Or(l, r) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1205,7 +1205,7 @@ func (a *expr) genBinOpXor(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1247,15 +1247,15 @@ func (a *expr) genBinOpXor(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.Xor(r) - a.eval = func() *bignum.Integer { return val } + val := l.Xor(l, r) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1301,7 +1301,7 @@ func (a *expr) genBinOpAndNot(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1343,15 +1343,15 @@ func (a *expr) genBinOpAndNot(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *idealIntType: l := l.asIdealInt()() r := r.asIdealInt()() - val := l.AndNot(r) - a.eval = func() *bignum.Integer { return val } + val := l.AndNot(l, r) + a.eval = func() *big.Int { return val } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1397,7 +1397,7 @@ func (a *expr) genBinOpShl(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1439,10 +1439,10 @@ func (a *expr) genBinOpShl(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1488,7 +1488,7 @@ func (a *expr) genBinOpShr(l, r *expr) { return uint64(uint(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } case *intType: lf := l.asInt() @@ -1530,10 +1530,10 @@ func (a *expr) genBinOpShr(l, r *expr) { return int64(int(ret)) } default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1578,7 +1578,7 @@ func (a *expr) genBinOpLss(l, r *expr) { return l < r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1623,7 +1623,7 @@ func (a *expr) genBinOpGtr(l, r *expr) { return l > r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1668,7 +1668,7 @@ func (a *expr) genBinOpLeq(l, r *expr) { return l <= r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1713,7 +1713,7 @@ func (a *expr) genBinOpGeq(l, r *expr) { return l >= r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1786,7 +1786,7 @@ func (a *expr) genBinOpEql(l, r *expr) { return l == r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1859,7 +1859,7 @@ func (a *expr) genBinOpNeq(l, r *expr) { return l != r } default: - log.Crashf("unexpected type %v at %v", l.t, a.pos) + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -1899,7 +1899,7 @@ func genAssign(lt Type, r *expr) func(lv Value, t *Thread) { rf := r.asMap() return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) } default: - log.Crashf("unexpected left operand type %v at %v", lt, r.pos) + log.Panicf("unexpected left operand type %v at %v", lt, r.pos) } panic("fail") } diff --git a/src/pkg/exp/eval/expr_test.go b/src/pkg/exp/eval/expr_test.go index b36554183..0dbce4315 100644 --- a/src/pkg/exp/eval/expr_test.go +++ b/src/pkg/exp/eval/expr_test.go @@ -5,7 +5,7 @@ package eval import ( - "exp/bignum" + "big" "testing" ) @@ -22,7 +22,7 @@ var implLimit = "implementation limit" var mustBeUnsigned = "must be unsigned" var divByZero = "divide by zero" -var hugeInteger = bignum.Int(1).Shl(64) +var hugeInteger = new(big.Int).Lsh(idealOne, 64) var exprTests = []test{ Val("i", 1), @@ -30,9 +30,9 @@ var exprTests = []test{ // TODO(austin) Test variable in constant context //CErr("t", typeAsExpr), - Val("'a'", bignum.Int('a')), - Val("'\\uffff'", bignum.Int('\uffff')), - Val("'\\n'", bignum.Int('\n')), + Val("'a'", big.NewInt('a')), + Val("'\\uffff'", big.NewInt('\uffff')), + Val("'\\n'", big.NewInt('\n')), CErr("''+x", badCharLit), // Produces two parse errors //CErr("'''", ""), @@ -40,10 +40,10 @@ var exprTests = []test{ CErr("'\\z'", unknownEscape), CErr("'ab'", badCharLit), - Val("1.0", bignum.Rat(1, 1)), - Val("1.", bignum.Rat(1, 1)), - Val(".1", bignum.Rat(1, 10)), - Val("1e2", bignum.Rat(100, 1)), + Val("1.0", big.NewRat(1, 1)), + Val("1.", big.NewRat(1, 1)), + Val(".1", big.NewRat(1, 10)), + Val("1e2", big.NewRat(100, 1)), Val("\"abc\"", "abc"), Val("\"\"", ""), @@ -140,12 +140,12 @@ var exprTests = []test{ CErr("&c", badAddrOf), Val("*(&ai[0])", 1), - Val("+1", bignum.Int(+1)), - Val("+1.0", bignum.Rat(1, 1)), - Val("01.5", bignum.Rat(15, 10)), + Val("+1", big.NewInt(+1)), + Val("+1.0", big.NewRat(1, 1)), + Val("01.5", big.NewRat(15, 10)), CErr("+\"x\"", opTypes), - Val("-42", bignum.Int(-42)), + Val("-42", big.NewInt(-42)), Val("-i", -1), Val("-f", -1.0), // 6g bug? @@ -154,8 +154,8 @@ var exprTests = []test{ // TODO(austin) Test unary ! - Val("^2", bignum.Int(^2)), - Val("^(-2)", bignum.Int(^(-2))), + Val("^2", big.NewInt(^2)), + Val("^(-2)", big.NewInt(^(-2))), CErr("^2.0", opTypes), CErr("^2.5", opTypes), Val("^i", ^1), @@ -165,67 +165,66 @@ var exprTests = []test{ Val("1+i", 2), Val("1+u", uint(2)), Val("3.0+i", 4), - Val("1+1", bignum.Int(2)), + Val("1+1", big.NewInt(2)), Val("f+f", 2.0), Val("1+f", 2.0), - Val("1.0+1", bignum.Rat(2, 1)), + Val("1.0+1", big.NewRat(2, 1)), Val("\"abc\" + \"def\"", "abcdef"), CErr("i+u", opTypes), CErr("-1+u", constantUnderflows), // TODO(austin) Test named types - Val("2-1", bignum.Int(1)), - Val("2.0-1", bignum.Rat(1, 1)), + Val("2-1", big.NewInt(1)), + Val("2.0-1", big.NewRat(1, 1)), Val("f-2", -1.0), - // TOOD(austin) bignum can't do negative 0? - //Val("-0.0", XXX), - Val("2*2", bignum.Int(4)), + Val("-0.0", big.NewRat(0, 1)), + Val("2*2", big.NewInt(4)), Val("2*i", 2), - Val("3/2", bignum.Int(1)), + Val("3/2", big.NewInt(1)), Val("3/i", 3), CErr("1/0", divByZero), CErr("1.0/0", divByZero), RErr("i/0", divByZero), - Val("3%2", bignum.Int(1)), + Val("3%2", big.NewInt(1)), Val("i%2", 1), CErr("3%0", divByZero), CErr("3.0%0", opTypes), RErr("i%0", divByZero), // Examples from "Arithmetic operators" - Val("5/3", bignum.Int(1)), + Val("5/3", big.NewInt(1)), Val("(i+4)/(i+2)", 1), - Val("5%3", bignum.Int(2)), + Val("5%3", big.NewInt(2)), Val("(i+4)%(i+2)", 2), - Val("-5/3", bignum.Int(-1)), + Val("-5/3", big.NewInt(-1)), Val("(i-6)/(i+2)", -1), - Val("-5%3", bignum.Int(-2)), + Val("-5%3", big.NewInt(-2)), Val("(i-6)%(i+2)", -2), - Val("5/-3", bignum.Int(-1)), + Val("5/-3", big.NewInt(-1)), Val("(i+4)/(i-4)", -1), - Val("5%-3", bignum.Int(2)), + Val("5%-3", big.NewInt(2)), Val("(i+4)%(i-4)", 2), - Val("-5/-3", bignum.Int(1)), + Val("-5/-3", big.NewInt(1)), Val("(i-6)/(i-4)", 1), - Val("-5%-3", bignum.Int(-2)), + Val("-5%-3", big.NewInt(-2)), Val("(i-6)%(i-4)", -2), // Examples from "Arithmetic operators" - Val("11/4", bignum.Int(2)), + Val("11/4", big.NewInt(2)), Val("(i+10)/4", 2), - Val("11%4", bignum.Int(3)), + Val("11%4", big.NewInt(3)), Val("(i+10)%4", 3), - Val("11>>2", bignum.Int(2)), + Val("11>>2", big.NewInt(2)), Val("(i+10)>>2", 2), - Val("11&3", bignum.Int(3)), + Val("11&3", big.NewInt(3)), Val("(i+10)&3", 3), - Val("-11/4", bignum.Int(-2)), + Val("-11/4", big.NewInt(-2)), Val("(i-12)/4", -2), - Val("-11%4", bignum.Int(-3)), + Val("-11%4", big.NewInt(-3)), Val("(i-12)%4", -3), - Val("-11>>2", bignum.Int(-3)), + Val("-11>>2", big.NewInt(-3)), Val("(i-12)>>2", -3), - Val("-11&3", bignum.Int(1)), + Val("-11&3", big.NewInt(1)), Val("(i-12)&3", 1), // TODO(austin) Test bit ops @@ -234,29 +233,29 @@ var exprTests = []test{ // ideal int, negative ideal int, big ideal int, ideal // fractional float, ideal non-fractional float, int, uint, // and float. - Val("2<<2", bignum.Int(2<<2)), + Val("2<<2", big.NewInt(2<<2)), CErr("2<<(-1)", constantUnderflows), CErr("2<<0x10000000000000000", constantOverflows), CErr("2<<2.5", constantTruncated), - Val("2<<2.0", bignum.Int(2<<2.0)), + Val("2<<2.0", big.NewInt(2<<2.0)), CErr("2<<i", mustBeUnsigned), Val("2<<u", 2<<1), CErr("2<<f", opTypes), - Val("-2<<2", bignum.Int(-2<<2)), + Val("-2<<2", big.NewInt(-2<<2)), CErr("-2<<(-1)", constantUnderflows), CErr("-2<<0x10000000000000000", constantOverflows), CErr("-2<<2.5", constantTruncated), - Val("-2<<2.0", bignum.Int(-2<<2.0)), + Val("-2<<2.0", big.NewInt(-2<<2.0)), CErr("-2<<i", mustBeUnsigned), Val("-2<<u", -2<<1), CErr("-2<<f", opTypes), - Val("0x10000000000000000<<2", hugeInteger.Shl(2)), + Val("0x10000000000000000<<2", new(big.Int).Lsh(hugeInteger, 2)), CErr("0x10000000000000000<<(-1)", constantUnderflows), CErr("0x10000000000000000<<0x10000000000000000", constantOverflows), CErr("0x10000000000000000<<2.5", constantTruncated), - Val("0x10000000000000000<<2.0", hugeInteger.Shl(2)), + Val("0x10000000000000000<<2.0", new(big.Int).Lsh(hugeInteger, 2)), CErr("0x10000000000000000<<i", mustBeUnsigned), CErr("0x10000000000000000<<u", constantOverflows), CErr("0x10000000000000000<<f", opTypes), diff --git a/src/pkg/exp/eval/func.go b/src/pkg/exp/eval/func.go index e672d0783..cb1b579e4 100644 --- a/src/pkg/exp/eval/func.go +++ b/src/pkg/exp/eval/func.go @@ -43,16 +43,7 @@ type codeBuf struct { func newCodeBuf() *codeBuf { return &codeBuf{make(code, 0, 16)} } func (b *codeBuf) push(instr func(*Thread)) { - n := len(b.instrs) - if n >= cap(b.instrs) { - a := make(code, n, n*2) - for i := range b.instrs { - a[i] = b.instrs[i] - } - b.instrs = a - } - b.instrs = b.instrs[0 : n+1] - b.instrs[n] = instr + b.instrs = append(b.instrs, instr) } func (b *codeBuf) nextPC() uint { return uint(len(b.instrs)) } @@ -60,9 +51,7 @@ func (b *codeBuf) nextPC() uint { return uint(len(b.instrs)) } func (b *codeBuf) get() code { // Freeze this buffer into an array of exactly the right size a := make(code, len(b.instrs)) - for i := range b.instrs { - a[i] = b.instrs[i] - } + copy(a, b.instrs) return code(a) } diff --git a/src/pkg/exp/eval/gen.go b/src/pkg/exp/eval/gen.go index 969d65586..81863dd6f 100644 --- a/src/pkg/exp/eval/gen.go +++ b/src/pkg/exp/eval/gen.go @@ -40,16 +40,16 @@ type Type struct { var ( boolType = &Type{Repr: "*boolType", Value: "BoolValue", Native: "bool", As: "asBool"} uintType = &Type{Repr: "*uintType", Value: "UintValue", Native: "uint64", As: "asUint", - Sizes: []Size{Size{8, "uint8"}, Size{16, "uint16"}, Size{32, "uint32"}, Size{64, "uint64"}, Size{0, "uint"}}, + Sizes: []Size{{8, "uint8"}, {16, "uint16"}, {32, "uint32"}, {64, "uint64"}, {0, "uint"}}, } intType = &Type{Repr: "*intType", Value: "IntValue", Native: "int64", As: "asInt", - Sizes: []Size{Size{8, "int8"}, Size{16, "int16"}, Size{32, "int32"}, Size{64, "int64"}, Size{0, "int"}}, + Sizes: []Size{{8, "int8"}, {16, "int16"}, {32, "int32"}, {64, "int64"}, {0, "int"}}, } - idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*bignum.Integer", As: "asIdealInt", IsIdeal: true} + idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*big.Int", As: "asIdealInt", IsIdeal: true} floatType = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat", - Sizes: []Size{Size{32, "float32"}, Size{64, "float64"}, Size{0, "float"}}, + Sizes: []Size{{32, "float32"}, {64, "float64"}, {0, "float"}}, } - idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*bignum.Rational", As: "asIdealFloat", IsIdeal: true} + idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*big.Rat", As: "asIdealFloat", IsIdeal: true} stringType = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"} arrayType = &Type{Repr: "*ArrayType", Value: "ArrayValue", Native: "ArrayValue", As: "asArray", HasAssign: true} structType = &Type{Repr: "*StructType", Value: "StructValue", Native: "StructValue", As: "asStruct", HasAssign: true} @@ -93,41 +93,41 @@ var ( ) var unOps = []Op{ - Op{Name: "Neg", Expr: "-v", ConstExpr: "v.Neg()", Types: numbers}, - Op{Name: "Not", Expr: "!v", Types: bools}, - Op{Name: "Xor", Expr: "^v", ConstExpr: "v.Neg().Sub(bignum.Int(1))", Types: integers}, + {Name: "Neg", Expr: "-v", ConstExpr: "val.Neg(val)", Types: numbers}, + {Name: "Not", Expr: "!v", Types: bools}, + {Name: "Xor", Expr: "^v", ConstExpr: "val.Not(val)", Types: integers}, } var binOps = []Op{ - Op{Name: "Add", Expr: "l + r", ConstExpr: "l.Add(r)", Types: addable}, - Op{Name: "Sub", Expr: "l - r", ConstExpr: "l.Sub(r)", Types: numbers}, - Op{Name: "Mul", Expr: "l * r", ConstExpr: "l.Mul(r)", Types: numbers}, - Op{Name: "Quo", + {Name: "Add", Expr: "l + r", ConstExpr: "l.Add(l, r)", Types: addable}, + {Name: "Sub", Expr: "l - r", ConstExpr: "l.Sub(l, r)", Types: numbers}, + {Name: "Mul", Expr: "l * r", ConstExpr: "l.Mul(l, r)", Types: numbers}, + {Name: "Quo", Body: "if r == 0 { t.Abort(DivByZeroError{}) }; ret = l / r", - ConstExpr: "l.Quo(r)", + ConstExpr: "l.Quo(l, r)", Types: numbers, }, - Op{Name: "Rem", + {Name: "Rem", Body: "if r == 0 { t.Abort(DivByZeroError{}) }; ret = l % r", - ConstExpr: "l.Rem(r)", + ConstExpr: "l.Rem(l, r)", Types: integers, }, - Op{Name: "And", Expr: "l & r", ConstExpr: "l.And(r)", Types: integers}, - Op{Name: "Or", Expr: "l | r", ConstExpr: "l.Or(r)", Types: integers}, - Op{Name: "Xor", Expr: "l ^ r", ConstExpr: "l.Xor(r)", Types: integers}, - Op{Name: "AndNot", Expr: "l &^ r", ConstExpr: "l.AndNot(r)", Types: integers}, - Op{Name: "Shl", Expr: "l << r", ConstExpr: "l.Shl(uint(r.Value()))", + {Name: "And", Expr: "l & r", ConstExpr: "l.And(l, r)", Types: integers}, + {Name: "Or", Expr: "l | r", ConstExpr: "l.Or(l, r)", Types: integers}, + {Name: "Xor", Expr: "l ^ r", ConstExpr: "l.Xor(l, r)", Types: integers}, + {Name: "AndNot", Expr: "l &^ r", ConstExpr: "l.AndNot(l, r)", Types: integers}, + {Name: "Shl", Expr: "l << r", ConstExpr: "l.Lsh(l, uint(r.Value()))", AsRightName: "asUint", Types: shiftable, }, - Op{Name: "Shr", Expr: "l >> r", ConstExpr: "l.Shr(uint(r.Value()))", + {Name: "Shr", Expr: "l >> r", ConstExpr: "new(big.Int).Rsh(l, uint(r.Value()))", AsRightName: "asUint", Types: shiftable, }, - Op{Name: "Lss", Expr: "l < r", ConstExpr: "l.Cmp(r) < 0", ReturnType: "bool", Types: addable}, - Op{Name: "Gtr", Expr: "l > r", ConstExpr: "l.Cmp(r) > 0", ReturnType: "bool", Types: addable}, - Op{Name: "Leq", Expr: "l <= r", ConstExpr: "l.Cmp(r) <= 0", ReturnType: "bool", Types: addable}, - Op{Name: "Geq", Expr: "l >= r", ConstExpr: "l.Cmp(r) >= 0", ReturnType: "bool", Types: addable}, - Op{Name: "Eql", Expr: "l == r", ConstExpr: "l.Cmp(r) == 0", ReturnType: "bool", Types: cmpable}, - Op{Name: "Neq", Expr: "l != r", ConstExpr: "l.Cmp(r) != 0", ReturnType: "bool", Types: cmpable}, + {Name: "Lss", Expr: "l < r", ConstExpr: "l.Cmp(r) < 0", ReturnType: "bool", Types: addable}, + {Name: "Gtr", Expr: "l > r", ConstExpr: "l.Cmp(r) > 0", ReturnType: "bool", Types: addable}, + {Name: "Leq", Expr: "l <= r", ConstExpr: "l.Cmp(r) <= 0", ReturnType: "bool", Types: addable}, + {Name: "Geq", Expr: "l >= r", ConstExpr: "l.Cmp(r) >= 0", ReturnType: "bool", Types: addable}, + {Name: "Eql", Expr: "l == r", ConstExpr: "l.Cmp(r) == 0", ReturnType: "bool", Types: cmpable}, + {Name: "Neq", Expr: "l != r", ConstExpr: "l.Cmp(r) != 0", ReturnType: "bool", Types: cmpable}, } type Data struct { @@ -149,8 +149,8 @@ const templateStr = ` package eval import ( - "bignum"; - "log"; + "big" + "log" ) /* @@ -184,9 +184,9 @@ func (a *expr) asInterface() (func(*Thread) interface{}) { «.end» «.end» default: - log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos); + log.Panicf("unexpected expression node type %T at %v", a.eval, a.pos) } - panic("fail"); + panic("fail") } /* @@ -198,19 +198,19 @@ func (a *expr) genConstant(v Value) { «.repeated section Types» case «Repr»: «.section IsIdeal» - val := v.(«Value»).Get(); + val := v.(«Value»).Get() a.eval = func() «Native» { return val } «.or» a.eval = func(t *Thread) «Native» { return v.(«Value»).Get(t) } «.end» «.end» default: - log.Crashf("unexpected constant type %v at %v", a.t, a.pos); + log.Panicf("unexpected constant type %v at %v", a.t, a.pos) } } func (a *expr) genIdentOp(level, index int) { - a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) }; + a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) } switch a.t.lit().(type) { «.repeated section Types» «.section IsIdeal» @@ -220,12 +220,12 @@ func (a *expr) genIdentOp(level, index int) { «.end» «.end» default: - log.Crashf("unexpected identifier type %v at %v", a.t, a.pos); + log.Panicf("unexpected identifier type %v at %v", a.t, a.pos) } } func (a *expr) genFuncCall(call func(t *Thread) []Value) { - a.exec = func(t *Thread) { call(t)}; + a.exec = func(t *Thread) { call(t)} switch a.t.lit().(type) { «.repeated section Types» «.section IsIdeal» @@ -237,12 +237,12 @@ func (a *expr) genFuncCall(call func(t *Thread) []Value) { case *MultiType: a.eval = func(t *Thread) []Value { return call(t) } default: - log.Crashf("unexpected result type %v at %v", a.t, a.pos); + log.Panicf("unexpected result type %v at %v", a.t, a.pos) } } func (a *expr) genValue(vf func(*Thread) Value) { - a.evalAddr = vf; + a.evalAddr = vf switch a.t.lit().(type) { «.repeated section Types» «.section IsIdeal» @@ -252,7 +252,7 @@ func (a *expr) genValue(vf func(*Thread) Value) { «.end» «.end» default: - log.Crashf("unexpected result type %v at %v", a.t, a.pos); + log.Panicf("unexpected result type %v at %v", a.t, a.pos) } } @@ -262,29 +262,29 @@ func (a *expr) genUnaryOp«Name»(v *expr) { «.repeated section Types» case «Repr»: «.section IsIdeal» - v := v.«As»()(); - val := «ConstExpr»; + val := v.«As»()() + «ConstExpr» a.eval = func() «Native» { return val } «.or» - vf := v.«As»(); + vf := v.«As»() a.eval = func(t *Thread) «Native» { v := vf(t); return «Expr» } «.end» «.end» default: - log.Crashf("unexpected type %v at %v", a.t, a.pos); + log.Panicf("unexpected type %v at %v", a.t, a.pos) } } «.end» func (a *expr) genBinOpLogAnd(l, r *expr) { - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { return lf(t) && rf(t) } } func (a *expr) genBinOpLogOr(l, r *expr) { - lf := l.asBool(); - rf := r.asBool(); + lf := l.asBool() + rf := r.asBool() a.eval = func(t *Thread) bool { return lf(t) || rf(t) } } @@ -294,20 +294,20 @@ func (a *expr) genBinOp«Name»(l, r *expr) { «.repeated section Types» case «Repr»: «.section IsIdeal» - l := l.«As»()(); - r := r.«As»()(); - val := «ConstExpr»; + l := l.«As»()() + r := r.«As»()() + val := «ConstExpr» «.section ReturnType» a.eval = func(t *Thread) «ReturnType» { return val } «.or» a.eval = func() «Native» { return val } «.end» «.or» - lf := l.«As»(); - rf := r.«.section AsRightName»«@»«.or»«As»«.end»(); + lf := l.«As»() + rf := r.«.section AsRightName»«@»«.or»«As»«.end»() «.section ReturnType» a.eval = func(t *Thread) «@» { - l, r := lf(t), rf(t); + l, r := lf(t), rf(t) return «Expr» } «.or» @@ -316,22 +316,22 @@ func (a *expr) genBinOp«Name»(l, r *expr) { «.repeated section @» case «Bits»: a.eval = func(t *Thread) «Native» { - l, r := lf(t), rf(t); - var ret «Native»; + l, r := lf(t), rf(t) + var ret «Native» «.section Body» - «Body»; + «Body» «.or» - ret = «Expr»; + ret = «Expr» «.end» return «Native»(«Sized»(ret)) } «.end» default: - log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos); + log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } «.or» a.eval = func(t *Thread) «Native» { - l, r := lf(t), rf(t); + l, r := lf(t), rf(t) return «Expr» } «.end» @@ -339,7 +339,7 @@ func (a *expr) genBinOp«Name»(l, r *expr) { «.end» «.end» default: - log.Crashf("unexpected type %v at %v", l.t, a.pos); + log.Panicf("unexpected type %v at %v", l.t, a.pos) } } @@ -350,14 +350,14 @@ func genAssign(lt Type, r *expr) (func(lv Value, t *Thread)) { «.section IsIdeal» «.or» case «Repr»: - rf := r.«As»(); + rf := r.«As»() return func(lv Value, t *Thread) { «.section HasAssign»lv.Assign(t, rf(t))«.or»lv.(«Value»).Set(t, rf(t))«.end» } «.end» «.end» default: - log.Crashf("unexpected left operand type %v at %v", lt, r.pos); + log.Panicf("unexpected left operand type %v at %v", lt, r.pos) } - panic("fail"); + panic("fail") } ` diff --git a/src/pkg/exp/eval/main.go b/src/pkg/exp/eval/main.go index 6033088a3..d87e8f240 100644 --- a/src/pkg/exp/eval/main.go +++ b/src/pkg/exp/eval/main.go @@ -10,10 +10,12 @@ import ( "flag" "go/parser" "go/scanner" + "go/token" "io/ioutil" "os" ) +var fset = token.NewFileSet() var filename = flag.String("f", "", "file to run") func main() { @@ -25,12 +27,12 @@ func main() { println(err.String()) os.Exit(1) } - file, err := parser.ParseFile(*filename, data, nil, 0) + file, err := parser.ParseFile(fset, *filename, data, 0) if err != nil { println(err.String()) os.Exit(1) } - code, err := w.CompileDeclList(file.Decls) + code, err := w.CompileDeclList(fset, file.Decls) if err != nil { if list, ok := err.(scanner.ErrorList); ok { for _, e := range list { @@ -46,7 +48,7 @@ func main() { println(err.String()) os.Exit(1) } - code, err = w.Compile("init()") + code, err = w.Compile(fset, "init()") if code != nil { _, err := code.Run() if err != nil { @@ -54,7 +56,7 @@ func main() { os.Exit(1) } } - code, err = w.Compile("main()") + code, err = w.Compile(fset, "main()") if err != nil { println(err.String()) os.Exit(1) @@ -74,7 +76,7 @@ func main() { if err != nil { break } - code, err := w.Compile(line) + code, err := w.Compile(fset, line) if err != nil { println(err.String()) continue diff --git a/src/pkg/exp/eval/scope.go b/src/pkg/exp/eval/scope.go index 74ce32b59..66305de25 100644 --- a/src/pkg/exp/eval/scope.go +++ b/src/pkg/exp/eval/scope.go @@ -15,11 +15,11 @@ import ( // A definition can be a *Variable, *Constant, or Type. type Def interface { - Pos() token.Position + Pos() token.Pos } type Variable struct { - token.Position + VarPos token.Pos // Index of this variable in the Frame structure Index int // Static type of this variable @@ -30,10 +30,18 @@ type Variable struct { Init Value } +func (v *Variable) Pos() token.Pos { + return v.VarPos +} + type Constant struct { - token.Position - Type Type - Value Value + ConstPos token.Pos + Type Type + Value Value +} + +func (c *Constant) Pos() token.Pos { + return c.ConstPos } // A block represents a definition block in which a name may not be @@ -74,7 +82,7 @@ type Scope struct { func (b *block) enterChild() *block { if b.inner != nil && b.inner.scope == b.scope { - log.Crash("Failed to exit child block before entering another child") + log.Panic("Failed to exit child block before entering another child") } sub := &block{ outer: b, @@ -88,14 +96,14 @@ func (b *block) enterChild() *block { func (b *block) exit() { if b.outer == nil { - log.Crash("Cannot exit top-level block") + log.Panic("Cannot exit top-level block") } if b.outer.scope == b.scope { if b.outer.inner != b { - log.Crash("Already exited block") + log.Panic("Already exited block") } if b.inner != nil && b.inner.scope == b.scope { - log.Crash("Exit of parent block without exit of child block") + log.Panic("Exit of parent block without exit of child block") } } b.outer.inner = nil @@ -103,7 +111,7 @@ func (b *block) exit() { func (b *block) ChildScope() *Scope { if b.inner != nil && b.inner.scope == b.scope { - log.Crash("Failed to exit child block before entering a child scope") + log.Panic("Failed to exit child block before entering a child scope") } sub := b.enterChild() sub.offset = 0 @@ -111,12 +119,12 @@ func (b *block) ChildScope() *Scope { return sub.scope } -func (b *block) DefineVar(name string, pos token.Position, t Type) (*Variable, Def) { +func (b *block) DefineVar(name string, pos token.Pos, t Type) (*Variable, Def) { if prev, ok := b.defs[name]; ok { return nil, prev } v := b.defineSlot(t, false) - v.Position = pos + v.VarPos = pos b.defs[name] = v return v, nil } @@ -125,7 +133,7 @@ func (b *block) DefineTemp(t Type) *Variable { return b.defineSlot(t, true) } func (b *block) defineSlot(t Type, temp bool) *Variable { if b.inner != nil && b.inner.scope == b.scope { - log.Crash("Failed to exit child block before defining variable") + log.Panic("Failed to exit child block before defining variable") } index := -1 if !b.global || temp { @@ -135,11 +143,11 @@ func (b *block) defineSlot(t Type, temp bool) *Variable { b.scope.maxVars = index + 1 } } - v := &Variable{token.Position{}, index, t, nil} + v := &Variable{token.NoPos, index, t, nil} return v } -func (b *block) DefineConst(name string, pos token.Position, t Type, v Value) (*Constant, Def) { +func (b *block) DefineConst(name string, pos token.Pos, t Type, v Value) (*Constant, Def) { if prev, ok := b.defs[name]; ok { return nil, prev } @@ -148,7 +156,7 @@ func (b *block) DefineConst(name string, pos token.Position, t Type, v Value) (* return c, nil } -func (b *block) DefineType(name string, pos token.Position, t Type) Type { +func (b *block) DefineType(name string, pos token.Pos, t Type) Type { if _, ok := b.defs[name]; ok { return nil } diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go index bcd81f04c..b9ffa94fa 100644 --- a/src/pkg/exp/eval/stmt.go +++ b/src/pkg/exp/eval/stmt.go @@ -5,7 +5,7 @@ package eval import ( - "exp/bignum" + "big" "log" "go/ast" "go/token" @@ -22,13 +22,13 @@ const ( type stmtCompiler struct { *blockCompiler - pos token.Position + pos token.Pos // This statement's label, or nil if it is not labeled. stmtLabel *label } func (a *stmtCompiler) diag(format string, args ...interface{}) { - a.diagAt(&a.pos, format, args) + a.diagAt(a.pos, format, args...) } /* @@ -65,7 +65,7 @@ type flowBuf struct { ents map[uint]*flowEnt // gotos is a map from goto positions to information on the // block at the point of the goto. - gotos map[*token.Position]*flowBlock + gotos map[token.Pos]*flowBlock // labels is a map from label name to information on the block // at the point of the label. labels are tracked by name, // since mutliple labels at the same PC can have different @@ -74,7 +74,7 @@ type flowBuf struct { } func newFlowBuf(cb *codeBuf) *flowBuf { - return &flowBuf{cb, make(map[uint]*flowEnt), make(map[*token.Position]*flowBlock), make(map[string]*flowBlock)} + return &flowBuf{cb, make(map[uint]*flowEnt), make(map[token.Pos]*flowBlock), make(map[string]*flowBlock)} } // put creates a flow control point for the next PC in the code buffer. @@ -82,7 +82,7 @@ func newFlowBuf(cb *codeBuf) *flowBuf { func (f *flowBuf) put(cond bool, term bool, jumps []*uint) { pc := f.cb.nextPC() if ent, ok := f.ents[pc]; ok { - log.Crashf("Flow entry already exists at PC %d: %+v", pc, ent) + log.Panicf("Flow entry already exists at PC %d: %+v", pc, ent) } f.ents[pc] = &flowEnt{cond, term, jumps, false} } @@ -123,8 +123,8 @@ func newFlowBlock(target string, b *block) *flowBlock { // putGoto captures the block at a goto statement. This should be // called in addition to putting a flow control point. -func (f *flowBuf) putGoto(pos token.Position, target string, b *block) { - f.gotos[&pos] = newFlowBlock(target, b) +func (f *flowBuf) putGoto(pos token.Pos, target string, b *block) { + f.gotos[pos] = newFlowBlock(target, b) } // putLabel captures the block at a label. @@ -138,7 +138,7 @@ func (f *flowBuf) putLabel(name string, b *block) { func (f *flowBuf) reachesEnd(pc uint) bool { endPC := f.cb.nextPC() if pc > endPC { - log.Crashf("Reached bad PC %d past end PC %d", pc, endPC) + log.Panicf("Reached bad PC %d past end PC %d", pc, endPC) } for ; pc < endPC; pc++ { @@ -210,15 +210,12 @@ func (f *flowBuf) gotosObeyScopes(a *compiler) { */ func (a *stmtCompiler) defineVar(ident *ast.Ident, t Type) *Variable { - v, prev := a.block.DefineVar(ident.Name(), ident.Pos(), t) + v, prev := a.block.DefineVar(ident.Name, ident.Pos(), t) if prev != nil { - // TODO(austin) It's silly that we have to capture - // Pos() in a variable. - pos := prev.Pos() - if pos.IsValid() { - a.diagAt(ident, "variable %s redeclared in this block\n\tprevious declaration at %s", ident.Name(), &pos) + if prev.Pos().IsValid() { + a.diagAt(ident.Pos(), "variable %s redeclared in this block\n\tprevious declaration at %s", ident.Name, a.fset.Position(prev.Pos())) } else { - a.diagAt(ident, "variable %s redeclared in this block", ident.Name()) + a.diagAt(ident.Pos(), "variable %s redeclared in this block", ident.Name) } return nil } @@ -239,7 +236,7 @@ func (a *stmtCompiler) defineVar(ident *ast.Ident, t Type) *Variable { func (a *stmtCompiler) compile(s ast.Stmt) { if a.block.inner != nil { - log.Crash("Child scope still entered") + log.Panic("Child scope still entered") } notimpl := false @@ -309,7 +306,7 @@ func (a *stmtCompiler) compile(s ast.Stmt) { notimpl = true default: - log.Crashf("unexpected ast node type %T", s) + log.Panicf("unexpected ast node type %T", s) } if notimpl { @@ -317,7 +314,7 @@ func (a *stmtCompiler) compile(s ast.Stmt) { } if a.block.inner != nil { - log.Crash("Forgot to exit child scope") + log.Panic("Forgot to exit child scope") } } @@ -329,16 +326,16 @@ func (a *stmtCompiler) compileDeclStmt(s *ast.DeclStmt) { case *ast.FuncDecl: if !a.block.global { - log.Crash("FuncDecl at statement level") + log.Panic("FuncDecl at statement level") } case *ast.GenDecl: if decl.Tok == token.IMPORT && !a.block.global { - log.Crash("import at statement level") + log.Panic("import at statement level") } default: - log.Crashf("Unexpected Decl type %T", s.Decl) + log.Panicf("Unexpected Decl type %T", s.Decl) } a.compileDecl(s.Decl) } @@ -350,7 +347,7 @@ func (a *stmtCompiler) compileVarDecl(decl *ast.GenDecl) { // Declaration without assignment if spec.Type == nil { // Parser should have caught - log.Crash("Type and Values nil") + log.Panic("Type and Values nil") } t := a.compileType(a.block, spec.Type) // Define placeholders even if type compile failed @@ -381,13 +378,13 @@ func (a *stmtCompiler) compileDecl(decl ast.Decl) { } // Declare and initialize v before compiling func // so that body can refer to itself. - c, prev := a.block.DefineConst(d.Name.Name(), a.pos, decl.Type, decl.Type.Zero()) + c, prev := a.block.DefineConst(d.Name.Name, a.pos, decl.Type, decl.Type.Zero()) if prev != nil { pos := prev.Pos() if pos.IsValid() { - a.diagAt(d.Name, "identifier %s redeclared in this block\n\tprevious declaration at %s", d.Name.Name(), &pos) + a.diagAt(d.Name.Pos(), "identifier %s redeclared in this block\n\tprevious declaration at %s", d.Name.Name, a.fset.Position(pos)) } else { - a.diagAt(d.Name, "identifier %s redeclared in this block", d.Name.Name()) + a.diagAt(d.Name.Pos(), "identifier %s redeclared in this block", d.Name.Name) } } fn := a.compileFunc(a.block, decl, d.Body) @@ -400,9 +397,9 @@ func (a *stmtCompiler) compileDecl(decl ast.Decl) { case *ast.GenDecl: switch d.Tok { case token.IMPORT: - log.Crashf("%v not implemented", d.Tok) + log.Panicf("%v not implemented", d.Tok) case token.CONST: - log.Crashf("%v not implemented", d.Tok) + log.Panicf("%v not implemented", d.Tok) case token.TYPE: a.compileTypeDecl(a.block, d) case token.VAR: @@ -410,20 +407,20 @@ func (a *stmtCompiler) compileDecl(decl ast.Decl) { } default: - log.Crashf("Unexpected Decl type %T", decl) + log.Panicf("Unexpected Decl type %T", decl) } } func (a *stmtCompiler) compileLabeledStmt(s *ast.LabeledStmt) { // Define label - l, ok := a.labels[s.Label.Name()] + l, ok := a.labels[s.Label.Name] if ok { if l.resolved.IsValid() { - a.diag("label %s redeclared in this block\n\tprevious declaration at %s", s.Label.Name(), &l.resolved) + a.diag("label %s redeclared in this block\n\tprevious declaration at %s", s.Label.Name, a.fset.Position(l.resolved)) } } else { pc := badPC - l = &label{name: s.Label.Name(), gotoPC: &pc} + l = &label{name: s.Label.Name, gotoPC: &pc} a.labels[l.name] = l } l.desc = "regular label" @@ -486,14 +483,14 @@ func (a *stmtCompiler) compileIncDecStmt(s *ast.IncDecStmt) { op = token.SUB desc = "decrement statement" default: - log.Crashf("Unexpected IncDec token %v", s.Tok) + log.Panicf("Unexpected IncDec token %v", s.Tok) } effect, l := l.extractEffect(bc.block, desc) one := l.newExpr(IdealIntType, "constant") one.pos = s.Pos() - one.eval = func() *bignum.Integer { return bignum.Int(1) } + one.eval = func() *big.Int { return big.NewInt(1) } binop := l.compileBinaryExpr(op, l, one) if binop == nil { @@ -502,7 +499,7 @@ func (a *stmtCompiler) compileIncDecStmt(s *ast.IncDecStmt) { assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "", "") if assign == nil { - log.Crashf("compileAssign type check failed") + log.Panicf("compileAssign type check failed") } lf := l.evalAddr @@ -555,14 +552,14 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, // Check that it's an identifier ident, ok = le.(*ast.Ident) if !ok { - a.diagAt(le, "left side of := must be a name") + a.diagAt(le.Pos(), "left side of := must be a name") // Suppress new defitions errors nDefs++ continue } // Is this simply an assignment? - if _, ok := a.block.defs[ident.Name()]; ok { + if _, ok := a.block.defs[ident.Name]; ok { ident = nil break } @@ -607,7 +604,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, case ac.rmt.Elems[i].isFloat(): lt = FloatType default: - log.Crashf("unexpected ideal type %v", rs[i].t) + log.Panicf("unexpected ideal type %v", rs[i].t) } default: @@ -780,7 +777,7 @@ func (a *stmtCompiler) doAssignOp(s *ast.AssignStmt) { assign := a.compileAssign(s.Pos(), bc.block, l.t, []*expr{binop}, "assignment", "value") if assign == nil { - log.Crashf("compileAssign type check failed") + log.Panicf("compileAssign type check failed") } lf := l.evalAddr @@ -861,7 +858,7 @@ func (a *stmtCompiler) findLexicalLabel(name *ast.Ident, pred func(*label) bool, if name == nil && pred(l) { return l } - if name != nil && l.name == name.Name() { + if name != nil && l.name == name.Name { if !pred(l) { a.diag("cannot %s to %s %s", errOp, l.desc, l.name) return nil @@ -872,7 +869,7 @@ func (a *stmtCompiler) findLexicalLabel(name *ast.Ident, pred func(*label) bool, if name == nil { a.diag("%s outside %s", errOp, errCtx) } else { - a.diag("%s label %s not defined", errOp, name.Name()) + a.diag("%s label %s not defined", errOp, name.Name) } return nil } @@ -896,10 +893,10 @@ func (a *stmtCompiler) compileBranchStmt(s *ast.BranchStmt) { pc = l.continuePC case token.GOTO: - l, ok := a.labels[s.Label.Name()] + l, ok := a.labels[s.Label.Name] if !ok { pc := badPC - l = &label{name: s.Label.Name(), desc: "unresolved label", gotoPC: &pc, used: s.Pos()} + l = &label{name: s.Label.Name, desc: "unresolved label", gotoPC: &pc, used: s.Pos()} a.labels[l.name] = l } @@ -911,7 +908,7 @@ func (a *stmtCompiler) compileBranchStmt(s *ast.BranchStmt) { return default: - log.Crash("Unexpected branch token %v", s.Tok) + log.Panic("Unexpected branch token %v", s.Tok) } a.flow.put1(false, pc) @@ -1012,12 +1009,12 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { for _, c := range s.Body.List { clause, ok := c.(*ast.CaseClause) if !ok { - a.diagAt(clause, "switch statement must contain case clauses") + a.diagAt(clause.Pos(), "switch statement must contain case clauses") continue } if clause.Values == nil { if hasDefault { - a.diagAt(clause, "switch statement contains more than one default case") + a.diagAt(clause.Pos(), "switch statement contains more than one default case") } hasDefault = true } else { @@ -1039,7 +1036,7 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { case e == nil: // Error reported by compileExpr case cond == nil && !e.t.isBoolean(): - a.diagAt(v, "'case' condition must be boolean") + a.diagAt(v.Pos(), "'case' condition must be boolean") case cond == nil: cases[i] = e.asBool() case cond != nil: @@ -1104,7 +1101,7 @@ func (a *stmtCompiler) compileSwitchStmt(s *ast.SwitchStmt) { // empty blocks to be empty // statements. if _, ok := s2.(*ast.EmptyStmt); !ok { - a.diagAt(s, "fallthrough statement must be final statement in case") + a.diagAt(s.Pos(), "fallthrough statement must be final statement in case") break } } @@ -1235,14 +1232,14 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) fu defer bodyScope.exit() for i, t := range decl.Type.In { if decl.InNames[i] != nil { - bodyScope.DefineVar(decl.InNames[i].Name(), decl.InNames[i].Pos(), t) + bodyScope.DefineVar(decl.InNames[i].Name, decl.InNames[i].Pos(), t) } else { bodyScope.DefineTemp(t) } } for i, t := range decl.Type.Out { if decl.OutNames[i] != nil { - bodyScope.DefineVar(decl.OutNames[i].Name(), decl.OutNames[i].Pos(), t) + bodyScope.DefineVar(decl.OutNames[i].Name, decl.OutNames[i].Pos(), t) } else { bodyScope.DefineTemp(t) } @@ -1275,7 +1272,7 @@ func (a *compiler) compileFunc(b *block, decl *FuncDecl, body *ast.BlockStmt) fu // this if there were no errors compiling the body. if len(decl.Type.Out) > 0 && fc.flow.reachesEnd(0) { // XXX(Spec) Not specified. - a.diagAt(&body.Rbrace, "function ends without a return statement") + a.diagAt(body.Rbrace, "function ends without a return statement") return nil } @@ -1290,7 +1287,7 @@ func (a *funcCompiler) checkLabels() { nerr := a.numError() for _, l := range a.labels { if !l.resolved.IsValid() { - a.diagAt(&l.used, "label %s not defined", l.name) + a.diagAt(l.used, "label %s not defined", l.name) } } if nerr != a.numError() { diff --git a/src/pkg/exp/eval/test.bash b/src/pkg/exp/eval/test.bash index 5d9ba1ae7..50b61fd00 100755 --- a/src/pkg/exp/eval/test.bash +++ b/src/pkg/exp/eval/test.bash @@ -10,10 +10,8 @@ set -e -GOBIN="${GOBIN:-$HOME/bin}" - -"$GOBIN"/gomake -"$GOBIN"/6g main.go && "$GOBIN"/6l main.6 +gomake +6g main.go && 6l main.6 ( for i in $(egrep -l '// \$G (\$D/)?\$F\.go \&\& \$L \$F\.\$A && \./\$A\.out' "$GOROOT"/test/*.go "$GOROOT"/test/*/*.go) do diff --git a/src/pkg/exp/eval/type.go b/src/pkg/exp/eval/type.go index b0fbe2156..db77ab198 100644 --- a/src/pkg/exp/eval/type.go +++ b/src/pkg/exp/eval/type.go @@ -5,7 +5,7 @@ package eval import ( - "exp/bignum" + "big" "go/ast" "go/token" "log" @@ -54,18 +54,18 @@ type Type interface { // String returns the string representation of this type. String() string // The position where this type was defined, if any. - Pos() token.Position + Pos() token.Pos } type BoundedType interface { Type // minVal returns the smallest value of this type. - minVal() *bignum.Rational + minVal() *big.Rat // maxVal returns the largest value of this type. - maxVal() *bignum.Rational + maxVal() *big.Rat } -var universePos = token.Position{"<universe>", 0, 0, 0} +var universePos = token.NoPos /* * Type array maps. These are used to memoize composite types. @@ -140,7 +140,7 @@ func (commonType) isFloat() bool { return false } func (commonType) isIdeal() bool { return false } -func (commonType) Pos() token.Position { return token.Position{} } +func (commonType) Pos() token.Pos { return token.NoPos } /* * Bool @@ -234,9 +234,9 @@ func (t *uintType) Zero() Value { panic("unexpected uint bit count") } -func (t *uintType) minVal() *bignum.Rational { return bignum.Rat(0, 1) } +func (t *uintType) minVal() *big.Rat { return big.NewRat(0, 1) } -func (t *uintType) maxVal() *bignum.Rational { +func (t *uintType) maxVal() *big.Rat { bits := t.Bits if bits == 0 { if t.Ptr { @@ -245,7 +245,10 @@ func (t *uintType) maxVal() *bignum.Rational { bits = uint(8 * unsafe.Sizeof(uint(0))) } } - return bignum.MakeRat(bignum.Int(1).Shl(bits).Add(bignum.Int(-1)), bignum.Nat(1)) + numer := big.NewInt(1) + numer.Lsh(numer, bits) + numer.Sub(numer, idealOne) + return new(big.Rat).SetInt(numer) } /* @@ -307,20 +310,25 @@ func (t *intType) Zero() Value { panic("unexpected int bit count") } -func (t *intType) minVal() *bignum.Rational { +func (t *intType) minVal() *big.Rat { bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(int(0))) } - return bignum.MakeRat(bignum.Int(-1).Shl(bits-1), bignum.Nat(1)) + numer := big.NewInt(-1) + numer.Lsh(numer, bits-1) + return new(big.Rat).SetInt(numer) } -func (t *intType) maxVal() *bignum.Rational { +func (t *intType) maxVal() *big.Rat { bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(int(0))) } - return bignum.MakeRat(bignum.Int(1).Shl(bits-1).Add(bignum.Int(-1)), bignum.Nat(1)) + numer := big.NewInt(1) + numer.Lsh(numer, bits-1) + numer.Sub(numer, idealOne) + return new(big.Rat).SetInt(numer) } /* @@ -346,7 +354,7 @@ func (t *idealIntType) isIdeal() bool { return true } func (t *idealIntType) String() string { return "ideal integer" } -func (t *idealIntType) Zero() Value { return &idealIntV{bignum.Int(0)} } +func (t *idealIntType) Zero() Value { return &idealIntV{idealZero} } /* * Float @@ -393,12 +401,12 @@ func (t *floatType) Zero() Value { panic("unexpected float bit count") } -var maxFloat32Val = bignum.MakeRat(bignum.Int(0xffffff).Shl(127-23), bignum.Nat(1)) -var maxFloat64Val = bignum.MakeRat(bignum.Int(0x1fffffffffffff).Shl(1023-52), bignum.Nat(1)) -var minFloat32Val = maxFloat32Val.Neg() -var minFloat64Val = maxFloat64Val.Neg() +var maxFloat32Val *big.Rat +var maxFloat64Val *big.Rat +var minFloat32Val *big.Rat +var minFloat64Val *big.Rat -func (t *floatType) minVal() *bignum.Rational { +func (t *floatType) minVal() *big.Rat { bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(float(0))) @@ -409,11 +417,11 @@ func (t *floatType) minVal() *bignum.Rational { case 64: return minFloat64Val } - log.Crashf("unexpected floating point bit count: %d", bits) + log.Panicf("unexpected floating point bit count: %d", bits) panic("unreachable") } -func (t *floatType) maxVal() *bignum.Rational { +func (t *floatType) maxVal() *big.Rat { bits := t.Bits if bits == 0 { bits = uint(8 * unsafe.Sizeof(float(0))) @@ -424,7 +432,7 @@ func (t *floatType) maxVal() *bignum.Rational { case 64: return maxFloat64Val } - log.Crashf("unexpected floating point bit count: %d", bits) + log.Panicf("unexpected floating point bit count: %d", bits) panic("unreachable") } @@ -451,7 +459,7 @@ func (t *idealFloatType) isIdeal() bool { return true } func (t *idealFloatType) String() string { return "ideal float" } -func (t *idealFloatType) Zero() Value { return &idealFloatV{bignum.Rat(1, 0)} } +func (t *idealFloatType) Zero() Value { return &idealFloatV{big.NewRat(0, 1)} } /* * String @@ -704,6 +712,7 @@ var ( panicType = &FuncType{builtin: "panic"} printType = &FuncType{builtin: "print"} printlnType = &FuncType{builtin: "println"} + copyType = &FuncType{builtin: "copy"} ) // Two function types are identical if they have the same number of @@ -763,7 +772,7 @@ func typeListString(ts []Type, ns []*ast.Ident) string { s += ", " } if ns != nil && ns[i] != nil { - s += ns[i].Name() + " " + s += ns[i].Name + " " } if t == nil { // Some places use nil types to represent errors @@ -807,7 +816,7 @@ type FuncDecl struct { func (t *FuncDecl) String() string { s := "func" if t.Name != nil { - s += " " + t.Name.Name() + s += " " + t.Name.Name } s += funcTypeString(t.Type, t.InNames, t.OutNames) return s @@ -861,9 +870,7 @@ func NewInterfaceType(methods []IMethod, embeds []*InterfaceType) *InterfaceType // Combine methods allMethods := make([]IMethod, nMethods) - for i, m := range methods { - allMethods[i] = m - } + copy(allMethods, methods) n := len(methods) for _, e := range embeds { for _, m := range e.methods { @@ -1093,8 +1100,8 @@ type Method struct { } type NamedType struct { - token.Position - Name string + NamePos token.Pos + Name string // Underlying type. If incomplete is true, this will be nil. // If incomplete is false and this is still nil, then this is // a placeholder type representing an error. @@ -1107,12 +1114,16 @@ type NamedType struct { // TODO(austin) This is temporarily needed by the debugger's remote // type parser. This should only be possible with block.DefineType. func NewNamedType(name string) *NamedType { - return &NamedType{token.Position{}, name, nil, true, make(map[string]Method)} + return &NamedType{token.NoPos, name, nil, true, make(map[string]Method)} +} + +func (t *NamedType) Pos() token.Pos { + return t.NamePos } func (t *NamedType) Complete(def Type) { if !t.incomplete { - log.Crashf("cannot complete already completed NamedType %+v", *t) + log.Panicf("cannot complete already completed NamedType %+v", *t) } // We strip the name from def because multiple levels of // naming are useless. @@ -1221,6 +1232,15 @@ func (t *MultiType) Zero() Value { */ func init() { + numer := big.NewInt(0xffffff) + numer.Lsh(numer, 127-23) + maxFloat32Val = new(big.Rat).SetInt(numer) + numer.SetInt64(0x1fffffffffffff) + numer.Lsh(numer, 1023-52) + maxFloat64Val = new(big.Rat).SetInt(numer) + minFloat32Val = new(big.Rat).Neg(maxFloat32Val) + minFloat64Val = new(big.Rat).Neg(maxFloat64Val) + // To avoid portability issues all numeric types are distinct // except byte, which is an alias for uint8. @@ -1232,6 +1252,7 @@ func init() { universe.DefineConst("cap", universePos, capType, nil) universe.DefineConst("close", universePos, closeType, nil) universe.DefineConst("closed", universePos, closedType, nil) + universe.DefineConst("copy", universePos, copyType, nil) universe.DefineConst("len", universePos, lenType, nil) universe.DefineConst("make", universePos, makeType, nil) universe.DefineConst("new", universePos, newType, nil) diff --git a/src/pkg/exp/eval/typec.go b/src/pkg/exp/eval/typec.go index 80ac078a2..de90cf664 100644 --- a/src/pkg/exp/eval/typec.go +++ b/src/pkg/exp/eval/typec.go @@ -26,21 +26,21 @@ type typeCompiler struct { } func (a *typeCompiler) compileIdent(x *ast.Ident, allowRec bool) Type { - _, _, def := a.block.Lookup(x.Name()) + _, _, def := a.block.Lookup(x.Name) if def == nil { - a.diagAt(x, "%s: undefined", x.Name()) + a.diagAt(x.Pos(), "%s: undefined", x.Name) return nil } switch def := def.(type) { case *Constant: - a.diagAt(x, "constant %v used as type", x.Name()) + a.diagAt(x.Pos(), "constant %v used as type", x.Name) return nil case *Variable: - a.diagAt(x, "variable %v used as type", x.Name()) + a.diagAt(x.Pos(), "variable %v used as type", x.Name) return nil case *NamedType: if !allowRec && def.incomplete { - a.diagAt(x, "illegal recursive type") + a.diagAt(x.Pos(), "illegal recursive type") return nil } if !def.incomplete && def.Def == nil { @@ -51,7 +51,7 @@ func (a *typeCompiler) compileIdent(x *ast.Ident, allowRec bool) Type { case Type: return def } - log.Crashf("name %s has unknown type %T", x.Name(), def) + log.Panicf("name %s has unknown type %T", x.Name, def) return nil } @@ -68,7 +68,7 @@ func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type { } if _, ok := x.Len.(*ast.Ellipsis); ok { - a.diagAt(x.Len, "... array initailizers not implemented") + a.diagAt(x.Len.Pos(), "... array initailizers not implemented") return nil } l, ok := a.compileArrayLen(a.block, x.Len) @@ -76,7 +76,7 @@ func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type { return nil } if l < 0 { - a.diagAt(x.Len, "array length must be non-negative") + a.diagAt(x.Len.Pos(), "array length must be non-negative") return nil } if elem == nil { @@ -86,11 +86,11 @@ func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type { return NewArrayType(l, elem) } -func (a *typeCompiler) compileFields(fields *ast.FieldList, allowRec bool) ([]Type, []*ast.Ident, []token.Position, bool) { +func (a *typeCompiler) compileFields(fields *ast.FieldList, allowRec bool) ([]Type, []*ast.Ident, []token.Pos, bool) { n := fields.NumFields() ts := make([]Type, n) ns := make([]*ast.Ident, n) - ps := make([]token.Position, n) + ps := make([]token.Pos, n) bad := false if fields != nil { @@ -132,12 +132,12 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type // uniqueness of field names inherited from anonymous fields // at use time. fields := make([]StructField, len(ts)) - nameSet := make(map[string]token.Position, len(ts)) + nameSet := make(map[string]token.Pos, len(ts)) for i := range fields { // Compute field name and check anonymous fields var name string if names[i] != nil { - name = names[i].Name() + name = names[i].Name } else { if ts[i] == nil { continue @@ -162,7 +162,7 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type // *T, and T itself, may not be a pointer or // interface type. if nt == nil { - a.diagAt(&poss[i], "embedded type must T or *T, where T is a named type") + a.diagAt(poss[i], "embedded type must T or *T, where T is a named type") bad = true continue } @@ -172,7 +172,7 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type lateCheck := a.lateCheck a.lateCheck = func() bool { if _, ok := nt.lit().(*PtrType); ok { - a.diagAt(&poss[i], "embedded type %v is a pointer type", nt) + a.diagAt(poss[i], "embedded type %v is a pointer type", nt) return false } return lateCheck() @@ -181,7 +181,7 @@ func (a *typeCompiler) compileStructType(x *ast.StructType, allowRec bool) Type // Check name uniqueness if prev, ok := nameSet[name]; ok { - a.diagAt(&poss[i], "field %s redeclared\n\tprevious declaration at %s", name, &prev) + a.diagAt(poss[i], "field %s redeclared\n\tprevious declaration at %s", name, a.fset.Position(prev)) bad = true continue } @@ -227,7 +227,7 @@ func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) ts, names, poss, bad := a.compileFields(x.Methods, allowRec) methods := make([]IMethod, len(ts)) - nameSet := make(map[string]token.Position, len(ts)) + nameSet := make(map[string]token.Pos, len(ts)) embeds := make([]*InterfaceType, len(ts)) var nm, ne int @@ -237,12 +237,12 @@ func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) } if names[i] != nil { - name := names[i].Name() + name := names[i].Name methods[nm].Name = name methods[nm].Type = ts[i].(*FuncType) nm++ if prev, ok := nameSet[name]; ok { - a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", name, &prev) + a.diagAt(poss[i], "method %s redeclared\n\tprevious declaration at %s", name, a.fset.Position(prev)) bad = true continue } @@ -251,7 +251,7 @@ func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) // Embedded interface it, ok := ts[i].lit().(*InterfaceType) if !ok { - a.diagAt(&poss[i], "embedded type must be an interface") + a.diagAt(poss[i], "embedded type must be an interface") bad = true continue } @@ -259,7 +259,7 @@ func (a *typeCompiler) compileInterfaceType(x *ast.InterfaceType, allowRec bool) ne++ for _, m := range it.methods { if prev, ok := nameSet[m.Name]; ok { - a.diagAt(&poss[i], "method %s redeclared\n\tprevious declaration at %s", m.Name, &prev) + a.diagAt(poss[i], "method %s redeclared\n\tprevious declaration at %s", m.Name, a.fset.Position(prev)) bad = true continue } @@ -288,13 +288,13 @@ func (a *typeCompiler) compileMapType(x *ast.MapType) Type { // that can be map keys except for function types. switch key.lit().(type) { case *StructType: - a.diagAt(x, "map key cannot be a struct type") + a.diagAt(x.Pos(), "map key cannot be a struct type") return nil case *ArrayType: - a.diagAt(x, "map key cannot be an array type") + a.diagAt(x.Pos(), "map key cannot be an array type") return nil case *SliceType: - a.diagAt(x, "map key cannot be a slice type") + a.diagAt(x.Pos(), "map key cannot be a slice type") return nil } return NewMapType(key, val) @@ -339,14 +339,14 @@ func (a *typeCompiler) compileType(x ast.Expr, allowRec bool) Type { return a.compileType(x.X, allowRec) case *ast.Ellipsis: - a.diagAt(x, "illegal use of ellipsis") + a.diagAt(x.Pos(), "illegal use of ellipsis") return nil } - a.diagAt(x, "expression used as type") + a.diagAt(x.Pos(), "expression used as type") return nil notimpl: - a.diagAt(x, "compileType: %T not implemented", x) + a.diagAt(x.Pos(), "compileType: %T not implemented", x) return nil } @@ -370,7 +370,7 @@ func (a *compiler) compileTypeDecl(b *block, decl *ast.GenDecl) bool { for _, spec := range decl.Specs { spec := spec.(*ast.TypeSpec) // Create incomplete type for this type - nt := b.DefineType(spec.Name.Name(), spec.Name.Pos(), nil) + nt := b.DefineType(spec.Name.Name, spec.Name.Pos(), nil) if nt != nil { nt.(*NamedType).incomplete = true } diff --git a/src/pkg/exp/eval/util.go b/src/pkg/exp/eval/util.go deleted file mode 100644 index ffe13e170..000000000 --- a/src/pkg/exp/eval/util.go +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package eval - -import ( - "exp/bignum" -) - -// TODO(austin): Maybe add to bignum in more general form -func ratToString(rat *bignum.Rational) string { - n, dnat := rat.Value() - d := bignum.MakeInt(false, dnat) - w, frac := n.QuoRem(d) - out := w.String() - if frac.IsZero() { - return out - } - - r := frac.Abs() - r = r.Mul(bignum.Nat(1e6)) - dec, tail := r.DivMod(dnat) - // Round last digit - if tail.Cmp(dnat.Div(bignum.Nat(2))) >= 0 { - dec = dec.Add(bignum.Nat(1)) - } - // Strip zeros - ten := bignum.Nat(10) - for !dec.IsZero() { - dec2, r2 := dec.DivMod(ten) - if !r2.IsZero() { - break - } - dec = dec2 - } - out += "." + dec.String() - return out -} diff --git a/src/pkg/exp/eval/value.go b/src/pkg/exp/eval/value.go index dce4bfcf3..cace2fd37 100644 --- a/src/pkg/exp/eval/value.go +++ b/src/pkg/exp/eval/value.go @@ -5,7 +5,7 @@ package eval import ( - "exp/bignum" + "big" "fmt" ) @@ -40,7 +40,7 @@ type IntValue interface { // because ideals are not l-values. type IdealIntValue interface { Value - Get() *bignum.Integer + Get() *big.Int } type FloatValue interface { @@ -51,7 +51,7 @@ type FloatValue interface { type IdealFloatValue interface { Value - Get() *bignum.Rational + Get() *big.Rat } type StringValue interface { @@ -272,7 +272,7 @@ func (v *intV) Set(t *Thread, x int64) { *v = intV(x) } */ type idealIntV struct { - V *bignum.Integer + V *big.Int } func (v *idealIntV) String() string { return v.V.String() } @@ -281,7 +281,7 @@ func (v *idealIntV) Assign(t *Thread, o Value) { v.V = o.(IdealIntValue).Get() } -func (v *idealIntV) Get() *bignum.Integer { return v.V } +func (v *idealIntV) Get() *big.Int { return v.V } /* * Float @@ -322,16 +322,16 @@ func (v *floatV) Set(t *Thread, x float64) { *v = floatV(x) } */ type idealFloatV struct { - V *bignum.Rational + V *big.Rat } -func (v *idealFloatV) String() string { return ratToString(v.V) } +func (v *idealFloatV) String() string { return v.V.FloatString(6) } func (v *idealFloatV) Assign(t *Thread, o Value) { v.V = o.(IdealFloatValue).Get() } -func (v *idealFloatV) Get() *bignum.Rational { return v.V } +func (v *idealFloatV) Get() *big.Rat { return v.V } /* * String @@ -586,8 +586,6 @@ func (v multiV) Assign(t *Thread, o Value) { * Universal constants */ -// TODO(austin) Nothing complains if I accidentally define init with -// arguments. Is this intentional? func init() { s := universe diff --git a/src/pkg/exp/eval/world.go b/src/pkg/exp/eval/world.go index edeb39a5f..02d18bd79 100644 --- a/src/pkg/exp/eval/world.go +++ b/src/pkg/exp/eval/world.go @@ -41,14 +41,14 @@ type stmtCode struct { code code } -func (w *World) CompileStmtList(stmts []ast.Stmt) (Code, os.Error) { +func (w *World) CompileStmtList(fset *token.FileSet, stmts []ast.Stmt) (Code, os.Error) { if len(stmts) == 1 { if s, ok := stmts[0].(*ast.ExprStmt); ok { - return w.CompileExpr(s.X) + return w.CompileExpr(fset, s.X) } } errors := new(scanner.ErrorVector) - cc := &compiler{errors, 0, 0} + cc := &compiler{fset, errors, 0, 0} cb := newCodeBuf() fc := &funcCompiler{ compiler: cc, @@ -73,12 +73,12 @@ func (w *World) CompileStmtList(stmts []ast.Stmt) (Code, os.Error) { return &stmtCode{w, fc.get()}, nil } -func (w *World) CompileDeclList(decls []ast.Decl) (Code, os.Error) { +func (w *World) CompileDeclList(fset *token.FileSet, decls []ast.Decl) (Code, os.Error) { stmts := make([]ast.Stmt, len(decls)) for i, d := range decls { stmts[i] = &ast.DeclStmt{d} } - return w.CompileStmtList(stmts) + return w.CompileStmtList(fset, stmts) } func (s *stmtCode) Type() Type { return nil } @@ -95,9 +95,9 @@ type exprCode struct { eval func(Value, *Thread) } -func (w *World) CompileExpr(e ast.Expr) (Code, os.Error) { +func (w *World) CompileExpr(fset *token.FileSet, e ast.Expr) (Code, os.Error) { errors := new(scanner.ErrorVector) - cc := &compiler{errors, 0, 0} + cc := &compiler{fset, errors, 0, 0} ec := cc.compileExpr(w.scope.block, false, e) if ec == nil { @@ -135,16 +135,16 @@ func (e *exprCode) Run() (Value, os.Error) { return v, err } -func (w *World) Compile(text string) (Code, os.Error) { - stmts, err := parser.ParseStmtList("input", text, nil) +func (w *World) Compile(fset *token.FileSet, text string) (Code, os.Error) { + stmts, err := parser.ParseStmtList(fset, "input", text) if err == nil { - return w.CompileStmtList(stmts) + return w.CompileStmtList(fset, stmts) } // Otherwise try as DeclList. - decls, err1 := parser.ParseDeclList("input", text, nil) + decls, err1 := parser.ParseDeclList(fset, "input", text) if err1 == nil { - return w.CompileDeclList(decls) + return w.CompileDeclList(fset, decls) } // Have to pick an error. @@ -162,13 +162,16 @@ func (e *RedefinitionError) String() string { res := "identifier " + e.Name + " redeclared" pos := e.Prev.Pos() if pos.IsValid() { - res += "; previous declaration at " + pos.String() + // TODO: fix this - currently this code is not reached by the tests + // need to get a file set (fset) from somewhere + //res += "; previous declaration at " + fset.Position(pos).String() + panic(0) } return res } func (w *World) DefineConst(name string, t Type, val Value) os.Error { - _, prev := w.scope.DefineConst(name, token.Position{}, t, val) + _, prev := w.scope.DefineConst(name, token.NoPos, t, val) if prev != nil { return &RedefinitionError{name, prev} } @@ -176,7 +179,7 @@ func (w *World) DefineConst(name string, t Type, val Value) os.Error { } func (w *World) DefineVar(name string, t Type, val Value) os.Error { - v, prev := w.scope.DefineVar(name, token.Position{}, t) + v, prev := w.scope.DefineVar(name, token.NoPos, t) if prev != nil { return &RedefinitionError{name, prev} } diff --git a/src/pkg/exp/iterable/Makefile b/src/pkg/exp/iterable/Makefile deleted file mode 100644 index 9adf714da..000000000 --- a/src/pkg/exp/iterable/Makefile +++ /dev/null @@ -1,12 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -include ../../../Make.$(GOARCH) - -TARG=exp/iterable -GOFILES=\ - array.go\ - iterable.go\ - -include ../../../Make.pkg diff --git a/src/pkg/exp/iterable/array.go b/src/pkg/exp/iterable/array.go deleted file mode 100644 index b5c7b5c6e..000000000 --- a/src/pkg/exp/iterable/array.go +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package iterable - -// This file implements the Iterable interface on some primitive types. - -type ByteArray []byte - -func (a ByteArray) Iter() <-chan interface{} { - ch := make(chan interface{}) - go func() { - for _, e := range a { - ch <- e - } - close(ch) - }() - return ch -} - -type IntArray []int - -func (a IntArray) Iter() <-chan interface{} { - ch := make(chan interface{}) - go func() { - for _, e := range a { - ch <- e - } - close(ch) - }() - return ch -} - -type FloatArray []float - -func (a FloatArray) Iter() <-chan interface{} { - ch := make(chan interface{}) - go func() { - for _, e := range a { - ch <- e - } - close(ch) - }() - return ch -} - -type StringArray []string - -func (a StringArray) Iter() <-chan interface{} { - ch := make(chan interface{}) - go func() { - for _, e := range a { - ch <- e - } - close(ch) - }() - return ch -} diff --git a/src/pkg/exp/iterable/iterable.go b/src/pkg/exp/iterable/iterable.go deleted file mode 100644 index aefff9427..000000000 --- a/src/pkg/exp/iterable/iterable.go +++ /dev/null @@ -1,344 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// The iterable package provides several traversal and searching methods. -// It can be used on anything that satisfies the Iterable interface, -// including vector, though certain functions, such as Map, can also be used on -// something that would produce an infinite amount of data. -package iterable - -import ( - "container/list" - "container/vector" -) - -type Iterable interface { - // Iter should return a fresh channel each time it is called. - Iter() <-chan interface{} -} - -func not(f func(interface{}) bool) func(interface{}) bool { - return func(e interface{}) bool { return !f(e) } -} - -// All tests whether f is true for every element of iter. -func All(iter Iterable, f func(interface{}) bool) bool { - for e := range iter.Iter() { - if !f(e) { - return false - } - } - return true -} - -// Any tests whether f is true for at least one element of iter. -func Any(iter Iterable, f func(interface{}) bool) bool { - return !All(iter, not(f)) -} - -// Data returns a slice containing the elements of iter. -func Data(iter Iterable) []interface{} { - vec := new(vector.Vector) - for e := range iter.Iter() { - vec.Push(e) - } - return vec.Data() -} - -// filteredIterable is a struct that implements Iterable with each element -// passed through a filter. -type filteredIterable struct { - it Iterable - f func(interface{}) bool -} - -func (f *filteredIterable) iterate(out chan<- interface{}) { - for e := range f.it.Iter() { - if f.f(e) { - out <- e - } - } - close(out) -} - -func (f *filteredIterable) Iter() <-chan interface{} { - ch := make(chan interface{}) - go f.iterate(ch) - return ch -} - -// Filter returns an Iterable that returns the elements of iter that satisfy f. -func Filter(iter Iterable, f func(interface{}) bool) Iterable { - return &filteredIterable{iter, f} -} - -// Find returns the first element of iter that satisfies f. -// Returns nil if no such element is found. -func Find(iter Iterable, f func(interface{}) bool) interface{} { - for e := range Filter(iter, f).Iter() { - return e - } - return nil -} - -// Injector is a type representing a function that takes two arguments, -// an accumulated value and an element, and returns the next accumulated value. -// See the Inject function. -type Injector func(interface{}, interface{}) interface{} - -// Inject combines the elements of iter by repeatedly calling f with an -// accumulated value and each element in order. The starting accumulated value -// is initial, and after each call the accumulated value is set to the return -// value of f. For instance, to compute a sum: -// var arr IntArray = []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; -// sum := iterable.Inject(arr, 0, -// func(ax interface {}, x interface {}) interface {} { -// return ax.(int) + x.(int) }).(int) -func Inject(iter Iterable, initial interface{}, f Injector) interface{} { - acc := initial - for e := range iter.Iter() { - acc = f(acc, e) - } - return acc -} - -// mappedIterable is a helper struct that implements Iterable, returned by Map. -type mappedIterable struct { - it Iterable - f func(interface{}) interface{} -} - -func (m *mappedIterable) iterate(out chan<- interface{}) { - for e := range m.it.Iter() { - out <- m.f(e) - } - close(out) -} - -func (m *mappedIterable) Iter() <-chan interface{} { - ch := make(chan interface{}) - go m.iterate(ch) - return ch -} - -// Map returns an Iterable that returns the result of applying f to each -// element of iter. -func Map(iter Iterable, f func(interface{}) interface{}) Iterable { - return &mappedIterable{iter, f} -} - -// Partition(iter, f) returns Filter(iter, f) and Filter(iter, !f). -func Partition(iter Iterable, f func(interface{}) bool) (Iterable, Iterable) { - return Filter(iter, f), Filter(iter, not(f)) -} - -// A Func is a function that, when called, sends the -// iterable values on a channel. -type Func func(chan<- interface{}) - -// Iter creates and returns a new channel; it starts a -// goroutine running f to send values to the channel. -func (f Func) Iter() <-chan interface{} { - ch := make(chan interface{}) - go f(ch) - return ch -} - -// Take returns an Iterable that contains the first n elements of iter. -func Take(iter Iterable, n int) Iterable { return Slice(iter, 0, n) } - -// TakeWhile returns an Iterable that contains elements from iter while f is true. -func TakeWhile(iter Iterable, f func(interface{}) bool) Iterable { - return Func(func(ch chan<- interface{}) { - for v := range iter.Iter() { - if !f(v) { - break - } - ch <- v - } - close(ch) - }) -} - -// Drop returns an Iterable that returns each element of iter after the first n elements. -func Drop(iter Iterable, n int) Iterable { - return Func(func(ch chan<- interface{}) { - m := n - for v := range iter.Iter() { - if m > 0 { - m-- - continue - } - ch <- v - } - close(ch) - }) -} - -// DropWhile returns an Iterable that returns each element of iter after the initial sequence for which f returns true. -func DropWhile(iter Iterable, f func(interface{}) bool) Iterable { - return Func(func(ch chan<- interface{}) { - drop := true - for v := range iter.Iter() { - if drop { - if f(v) { - continue - } - drop = false - } - ch <- v - } - close(ch) - }) -} - -// Cycle repeats the values of iter in order infinitely. -func Cycle(iter Iterable) Iterable { - return Func(func(ch chan<- interface{}) { - for { - for v := range iter.Iter() { - ch <- v - } - } - }) -} - -// Chain returns an Iterable that concatentates all values from the specified Iterables. -func Chain(args []Iterable) Iterable { - return Func(func(ch chan<- interface{}) { - for _, e := range args { - for v := range e.Iter() { - ch <- v - } - } - close(ch) - }) -} - -// Zip returns an Iterable of []interface{} consisting of the next element from -// each input Iterable. The length of the returned Iterable is the minimum of -// the lengths of the input Iterables. -func Zip(args []Iterable) Iterable { - return Func(func(ch chan<- interface{}) { - defer close(ch) - if len(args) == 0 { - return - } - iters := make([]<-chan interface{}, len(args)) - for i := 0; i < len(iters); i++ { - iters[i] = args[i].Iter() - } - for { - out := make([]interface{}, len(args)) - for i, v := range iters { - out[i] = <-v - if closed(v) { - return - } - } - ch <- out - } - }) -} - -// ZipWith returns an Iterable containing the result of executing f using arguments read from a and b. -func ZipWith2(f func(c, d interface{}) interface{}, a, b Iterable) Iterable { - return Map(Zip([]Iterable{a, b}), func(a1 interface{}) interface{} { - arr := a1.([]interface{}) - return f(arr[0], arr[1]) - }) -} - -// ZipWith returns an Iterable containing the result of executing f using arguments read from a, b and c. -func ZipWith3(f func(d, e, f interface{}) interface{}, a, b, c Iterable) Iterable { - return Map(Zip([]Iterable{a, b, c}), func(a1 interface{}) interface{} { - arr := a1.([]interface{}) - return f(arr[0], arr[1], arr[2]) - }) -} - -// Slice returns an Iterable that contains the elements from iter -// with indexes in [start, stop). -func Slice(iter Iterable, start, stop int) Iterable { - return Func(func(ch chan<- interface{}) { - defer close(ch) - i := 0 - for v := range iter.Iter() { - switch { - case i >= stop: - return - case i >= start: - ch <- v - } - i++ - } - }) -} - -// Repeat generates an infinite stream of v. -func Repeat(v interface{}) Iterable { - return Func(func(ch chan<- interface{}) { - for { - ch <- v - } - }) -} - -// RepeatTimes generates a stream of n copies of v. -func RepeatTimes(v interface{}, n int) Iterable { - return Func(func(ch chan<- interface{}) { - for i := 0; i < n; i++ { - ch <- v - } - close(ch) - }) -} - -// Group is the type for elements returned by the GroupBy function. -type Group struct { - Key interface{} // key value for matching items - Vals Iterable // Iterable for receiving values in the group -} - -// Key defines the interface required by the GroupBy function. -type Grouper interface { - // Return the key for the given value - Key(interface{}) interface{} - - // Compute equality for the given keys - Equal(a, b interface{}) bool -} - -// GroupBy combines sequences of logically identical values from iter using k -// to generate a key to compare values. Each value emitted by the returned -// Iterable is of type Group, which contains the key used for matching the -// values for the group, and an Iterable for retrieving all the values in the -// group. -func GroupBy(iter Iterable, k Grouper) Iterable { - return Func(func(ch chan<- interface{}) { - var curkey interface{} - var lst *list.List - // Basic strategy is to read one group at a time into a list prior to emitting the Group value - for v := range iter.Iter() { - kv := k.Key(v) - if lst == nil || !k.Equal(curkey, kv) { - if lst != nil { - ch <- Group{curkey, lst} - } - lst = list.New() - curkey = kv - } - lst.PushBack(v) - } - if lst != nil { - ch <- Group{curkey, lst} - } - close(ch) - }) -} - -// Unique removes duplicate values which occur consecutively using id to compute keys. -func Unique(iter Iterable, id Grouper) Iterable { - return Map(GroupBy(iter, id), func(v interface{}) interface{} { return v.(Group).Key }) -} diff --git a/src/pkg/exp/iterable/iterable_test.go b/src/pkg/exp/iterable/iterable_test.go deleted file mode 100644 index 1d60d4b91..000000000 --- a/src/pkg/exp/iterable/iterable_test.go +++ /dev/null @@ -1,387 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package iterable - -import ( - "container/vector" - "testing" -) - -func TestArrayTypes(t *testing.T) { - // Test that conversion works correctly. - bytes := ByteArray([]byte{1, 2, 3}) - if x := Data(bytes)[1].(byte); x != 2 { - t.Error("Data(bytes)[1].(byte) = %v, want 2", x) - } - ints := IntArray([]int{1, 2, 3}) - if x := Data(ints)[2].(int); x != 3 { - t.Error("Data(ints)[2].(int) = %v, want 3", x) - } - floats := FloatArray([]float{1, 2, 3}) - if x := Data(floats)[0].(float); x != 1 { - t.Error("Data(floats)[0].(float) = %v, want 1", x) - } - strings := StringArray([]string{"a", "b", "c"}) - if x := Data(strings)[1].(string); x != "b" { - t.Error(`Data(strings)[1].(string) = %q, want "b"`, x) - } -} - -var ( - oneToFive = IntArray{1, 2, 3, 4, 5} - sixToTen = IntArray{6, 7, 8, 9, 10} - elevenToTwenty = IntArray{11, 12, 13, 14, 15, 16, 17, 18, 19, 20} -) - -func isNegative(n interface{}) bool { return n.(int) < 0 } -func isPositive(n interface{}) bool { return n.(int) > 0 } -func isAbove3(n interface{}) bool { return n.(int) > 3 } -func isEven(n interface{}) bool { return n.(int)%2 == 0 } -func doubler(n interface{}) interface{} { return n.(int) * 2 } -func addOne(n interface{}) interface{} { return n.(int) + 1 } -func adder(acc interface{}, n interface{}) interface{} { - return acc.(int) + n.(int) -} - -// A stream of the natural numbers: 0, 1, 2, 3, ... -type integerStream struct{} - -func (i integerStream) Iter() <-chan interface{} { - ch := make(chan interface{}) - go func() { - for i := 0; ; i++ { - ch <- i - } - }() - return ch -} - -func TestAll(t *testing.T) { - if !All(oneToFive, isPositive) { - t.Error("All(oneToFive, isPositive) == false") - } - if All(oneToFive, isAbove3) { - t.Error("All(oneToFive, isAbove3) == true") - } -} - -func TestAny(t *testing.T) { - if Any(oneToFive, isNegative) { - t.Error("Any(oneToFive, isNegative) == true") - } - if !Any(oneToFive, isEven) { - t.Error("Any(oneToFive, isEven) == false") - } -} - -func assertArraysAreEqual(t *testing.T, res []interface{}, expected []int) { - if len(res) != len(expected) { - t.Errorf("len(res) = %v, want %v", len(res), len(expected)) - goto missing - } - for i := range res { - if v := res[i].(int); v != expected[i] { - t.Errorf("res[%v] = %v, want %v", i, v, expected[i]) - goto missing - } - } - return -missing: - t.Errorf("res = %v\nwant %v", res, expected) -} - -func TestFilter(t *testing.T) { - ints := integerStream{} - moreInts := Filter(ints, isAbove3).Iter() - res := make([]interface{}, 3) - for i := 0; i < 3; i++ { - res[i] = <-moreInts - } - assertArraysAreEqual(t, res, []int{4, 5, 6}) -} - -func TestFind(t *testing.T) { - ints := integerStream{} - first := Find(ints, isAbove3) - if first.(int) != 4 { - t.Errorf("Find(ints, isAbove3) = %v, want 4", first) - } -} - -func TestInject(t *testing.T) { - res := Inject(oneToFive, 0, adder) - if res.(int) != 15 { - t.Errorf("Inject(oneToFive, 0, adder) = %v, want 15", res) - } -} - -func TestMap(t *testing.T) { - res := Data(Map(Map(oneToFive, doubler), addOne)) - assertArraysAreEqual(t, res, []int{3, 5, 7, 9, 11}) -} - -func TestPartition(t *testing.T) { - ti, fi := Partition(oneToFive, isEven) - assertArraysAreEqual(t, Data(ti), []int{2, 4}) - assertArraysAreEqual(t, Data(fi), []int{1, 3, 5}) -} - -func TestTake(t *testing.T) { - res := Take(oneToFive, 2) - assertArraysAreEqual(t, Data(res), []int{1, 2}) - assertArraysAreEqual(t, Data(res), []int{1, 2}) // second test to ensure that .Iter() returns a new channel - - // take none - res = Take(oneToFive, 0) - assertArraysAreEqual(t, Data(res), []int{}) - - // try to take more than available - res = Take(oneToFive, 20) - assertArraysAreEqual(t, Data(res), oneToFive) -} - -func TestTakeWhile(t *testing.T) { - // take some - res := TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) <= 3 }) - assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) - assertArraysAreEqual(t, Data(res), []int{1, 2, 3}) // second test to ensure that .Iter() returns a new channel - - // take none - res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) > 3000 }) - assertArraysAreEqual(t, Data(res), []int{}) - - // take all - res = TakeWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3000 }) - assertArraysAreEqual(t, Data(res), oneToFive) -} - -func TestDrop(t *testing.T) { - // drop none - res := Drop(oneToFive, 0) - assertArraysAreEqual(t, Data(res), oneToFive) - assertArraysAreEqual(t, Data(res), oneToFive) // second test to ensure that .Iter() returns a new channel - - // drop some - res = Drop(oneToFive, 2) - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel - - // drop more than available - res = Drop(oneToFive, 88) - assertArraysAreEqual(t, Data(res), []int{}) -} - -func TestDropWhile(t *testing.T) { - // drop some - res := DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 3 }) - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) - assertArraysAreEqual(t, Data(res), []int{3, 4, 5}) // second test to ensure that .Iter() returns a new channel - - // test case where all elements are dropped - res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) < 100 }) - assertArraysAreEqual(t, Data(res), []int{}) - - // test case where none are dropped - res = DropWhile(oneToFive, func(v interface{}) bool { return v.(int) > 1000 }) - assertArraysAreEqual(t, Data(res), oneToFive) -} - -func TestCycle(t *testing.T) { - res := Cycle(oneToFive) - exp := []int{1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4} - - // read the first nineteen values from the iterable - out := make([]interface{}, 19) - for i, it := 0, res.Iter(); i < 19; i++ { - out[i] = <-it - } - assertArraysAreEqual(t, out, exp) - - res2 := Cycle(sixToTen) - exp2 := []int{6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9} - for i, it := 0, res2.Iter(); i < 19; i++ { - out[i] = <-it - } - assertArraysAreEqual(t, out, exp2) - - // ensure first iterator was not harmed - for i, it := 0, res.Iter(); i < 19; i++ { - out[i] = <-it - } - assertArraysAreEqual(t, out, exp) -} - -func TestChain(t *testing.T) { - - exp := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20} - res := Chain([]Iterable{oneToFive, sixToTen, elevenToTwenty}) - assertArraysAreEqual(t, Data(res), exp) - - // reusing the same iterator should produce the same result again - assertArraysAreEqual(t, Data(res), exp) - - // test short read from Chain - i := 0 - out := make([]interface{}, 4) - for v := range res.Iter() { - out[i] = v - i++ - if i == len(out) { - break - } - } - assertArraysAreEqual(t, out, exp[0:4]) - - // test zero length array - res = Chain([]Iterable{}) - assertArraysAreEqual(t, Data(res), []int{}) -} - -func TestZipWith(t *testing.T) { - exp := []int{7, 9, 11, 13, 15} - - // f with 2 args and 1 return value - f := func(a, b interface{}) interface{} { return a.(int) + b.(int) } - res := ZipWith2(f, oneToFive, sixToTen) - assertArraysAreEqual(t, Data(res), exp) - - // test again to make sure returns new iter each time - assertArraysAreEqual(t, Data(res), exp) - - // test a function with 3 args - f2 := func(a, b, c interface{}) interface{} { return a.(int) + b.(int) + c.(int) } - res = ZipWith3(f2, oneToFive, sixToTen, oneToFive) - exp = []int{8, 11, 14, 17, 20} - assertArraysAreEqual(t, Data(res), exp) - - // test a function with multiple values returned - f3 := func(a, b interface{}) interface{} { return ([]interface{}{a.(int) + 1, b.(int) + 1}) } - res = ZipWith2(f3, oneToFive, sixToTen) - - exp2 := [][]int{[]int{2, 7}, []int{3, 8}, []int{4, 9}, []int{5, 10}, []int{6, 11}} - i := 0 - for v := range res.Iter() { - out := v.([]interface{}) - assertArraysAreEqual(t, out, exp2[i]) - i++ - } - - // test different length iterators--should stop after shortest is exhausted - res = ZipWith2(f, elevenToTwenty, oneToFive) - exp = []int{12, 14, 16, 18, 20} - assertArraysAreEqual(t, Data(res), exp) -} - -func TestSlice(t *testing.T) { - out := Data(Slice(elevenToTwenty, 2, 6)) - exp := []int{13, 14, 15, 16} - assertArraysAreEqual(t, out, exp) - - // entire iterable - out = Data(Slice(elevenToTwenty, 0, len(elevenToTwenty))) - exp = []int{11, 12, 13, 14, 15, 16, 17, 18, 19, 20} - assertArraysAreEqual(t, out, exp) - - // empty slice at offset 0 - exp = []int{} - out = Data(Slice(elevenToTwenty, 0, 0)) - assertArraysAreEqual(t, out, exp) - - // slice upper bound exceeds length of iterable - exp = []int{1, 2, 3, 4, 5} - out = Data(Slice(oneToFive, 0, 88)) - assertArraysAreEqual(t, out, exp) - - // slice upper bounce is lower than lower bound - exp = []int{} - out = Data(Slice(oneToFive, 93, 4)) - assertArraysAreEqual(t, out, exp) - - // slice lower bound is greater than len of iterable - exp = []int{} - out = Data(Slice(oneToFive, 93, 108)) - assertArraysAreEqual(t, out, exp) -} - -func TestRepeat(t *testing.T) { - res := Repeat(42) - i := 0 - for v := range res.Iter() { - if v.(int) != 42 { - t.Fatal("Repeat returned the wrong value") - } - if i == 9 { - break - } - i++ - } -} - -func TestRepeatTimes(t *testing.T) { - res := RepeatTimes(84, 9) - exp := []int{84, 84, 84, 84, 84, 84, 84, 84, 84} - assertArraysAreEqual(t, Data(res), exp) - assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned - - // 0 repeat - res = RepeatTimes(7, 0) - exp = []int{} - assertArraysAreEqual(t, Data(res), exp) - - // negative repeat - res = RepeatTimes(7, -3) - exp = []int{} - assertArraysAreEqual(t, Data(res), exp) -} - -// a type that implements Key for ints -type intkey struct{} - -func (v intkey) Key(a interface{}) interface{} { - return a -} -func (v intkey) Equal(a, b interface{}) bool { return a.(int) == b.(int) } - -func TestGroupBy(t *testing.T) { - in := IntArray{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5} - exp := [][]int{[]int{1}, []int{2, 2}, []int{3, 3, 3}, []int{4, 4, 4, 4}, []int{5, 5, 5, 5, 5}} - i := 0 - for x := range GroupBy(in, intkey{}).Iter() { - gr := x.(Group) - if gr.Key.(int) != i+1 { - t.Fatal("group key wrong; expected", i+1, "but got", gr.Key.(int)) - } - vals := Data(gr.Vals) - assertArraysAreEqual(t, vals, exp[i]) - i++ - } - if i != 5 { - t.Fatal("did not return expected number of groups") - } - - // test 0 length Iterable - for _ = range GroupBy(IntArray([]int{}), &intkey{}).Iter() { - t.Fatal("iterator should be empty") - } - - // test case with only uniques - var out vector.Vector - for x := range GroupBy(elevenToTwenty, intkey{}).Iter() { - out.Push(x.(Group).Key) - } - assertArraysAreEqual(t, out.Data(), elevenToTwenty) -} - -func TestUnique(t *testing.T) { - in := IntArray([]int{1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5}) - exp := []int{1, 2, 3, 4, 5} - res := Unique(in, intkey{}) - assertArraysAreEqual(t, Data(res), exp) - assertArraysAreEqual(t, Data(res), exp) // second time to ensure new iter is returned - - // test case with only uniques - res = Unique(elevenToTwenty, intkey{}) - assertArraysAreEqual(t, Data(res), elevenToTwenty) -} diff --git a/src/pkg/exp/nacl/README b/src/pkg/exp/nacl/README deleted file mode 100644 index ec18f1d32..000000000 --- a/src/pkg/exp/nacl/README +++ /dev/null @@ -1,36 +0,0 @@ -Native Client support is still incomplete: -Native Client does not yet allow runtime code generation, -so Go's many uses of closures do not work. - -To try Native Client by running 4s (tetris) or 5s or Spacewar: - -1. Build the Go distribution for your native system. - -2. Download Native Client and install it. - http://nativeclient.googlecode.com/svn/trunk/src/native_client/documentation/getting_started.html - * You can stop after step 4 on those instructions - (the ./scons --prebuilt firefox_install). - -3. (optional) Install "./build/native_client/scons-out/opt-*/staging/sel_ldr" - from the Native Client distribution somewhere in your path as "nacl". - This will let you run binaries using "nacl 8.out". - -4. Build the Go distribution again, this time for Native Client: - cd $GOROOT/src - ./all-nacl.bash - * If you didn't do step 3, the tests at the end will fail, but that's okay. - * If you are on a Mac, your dock will flicker as the "nacl" binary - starts and stops while the tests run. You can stop the tests at any time. - -5. Run "godoc --http=:5103". - * This will run the godoc built for your host OS, not Native Client, - because all-nacl.bash doesn't install a nacl godoc. - * Note that there is a colon before the 5103 in the argument - (shorthand for 0.0.0.0:5103). - * The port must be 5103: that's the only port that Native Client - trusts to run binaries from. - -6. Open Firefox and visit one of: - * http://localhost:5103/src/pkg/exp/4s/4s.html - * http://localhost:5103/src/pkg/exp/4s/5s.html [sic] - * http://localhost:5103/src/pkg/exp/spacewar/spacewar.html diff --git a/src/pkg/exp/nacl/av/Makefile b/src/pkg/exp/nacl/av/Makefile deleted file mode 100644 index d966078ec..000000000 --- a/src/pkg/exp/nacl/av/Makefile +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -include ../../../../Make.$(GOARCH) - -TARG=exp/nacl/av -GOFILES=\ - av.go\ - event.go\ - image.go\ - -include ../../../../Make.pkg diff --git a/src/pkg/exp/nacl/av/av.go b/src/pkg/exp/nacl/av/av.go deleted file mode 100644 index 5c8728292..000000000 --- a/src/pkg/exp/nacl/av/av.go +++ /dev/null @@ -1,299 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Native Client audio/video - -// Package av implements audio and video access for Native Client -// binaries running standalone or embedded in a web browser window. -// -// The C version of the API is documented at -// http://nativeclient.googlecode.com/svn/data/docs_tarball/nacl/googleclient/native_client/scons-out/doc/html/group__audio__video.html -package av - -import ( - "exp/draw" - "exp/nacl/srpc" - "log" - "os" - "syscall" - "unsafe" -) - -var srpcEnabled = srpc.Enabled() - -// native_client/src/trusted/service_runtime/include/sys/audio_video.h - -// Subsystem values for Init. -const ( - SubsystemVideo = 1 << iota - SubsystemAudio - SubsystemEmbed -) -// SubsystemRawEvents; - -// Audio formats. -const ( - AudioFormatStereo44K = iota - AudioFormatStereo48K -) - -// A Window represents a connection to the Native Client window. -// It implements draw.Context. -type Window struct { - Embedded bool // running as part of a web page? - *Image // screen image - - mousec chan draw.Mouse - kbdc chan int - quitc chan bool - resizec chan bool -} - -// *Window implements draw.Context -var _ draw.Context = (*Window)(nil) - -func (w *Window) KeyboardChan() <-chan int { return w.kbdc } - -func (w *Window) MouseChan() <-chan draw.Mouse { - return w.mousec -} - -func (w *Window) QuitChan() <-chan bool { return w.quitc } - -func (w *Window) ResizeChan() <-chan bool { return w.resizec } - -func (w *Window) Screen() draw.Image { return w.Image } - -// Init initializes the Native Client subsystems specified by subsys. -// Init must be called before using any of the other functions -// in this package, and it must be called only once. -// -// If the SubsystemVideo flag is set, Init requests a window of size dx×dy. -// When embedded in a web page, the web page's window specification -// overrides the parameters to Init, so the returned Window may have -// a different size than requested. -// -// If the SubsystemAudio flag is set, Init requests a connection to the -// audio device carrying 44 kHz 16-bit stereo PCM audio samples. -func Init(subsys int, dx, dy int) (*Window, os.Error) { - xsubsys := subsys - if srpcEnabled { - waitBridge() - xsubsys &^= SubsystemVideo | SubsystemEmbed - } - - if xsubsys&SubsystemEmbed != 0 { - return nil, os.NewError("not embedded") - } - - w := new(Window) - err := multimediaInit(xsubsys) - if err != nil { - return nil, err - } - - if subsys&SubsystemVideo != 0 { - if dx, dy, err = videoInit(dx, dy); err != nil { - return nil, err - } - w.Image = newImage(dx, dy, bridge.pixel) - w.resizec = make(chan bool, 64) - w.kbdc = make(chan int, 64) - w.mousec = make(chan draw.Mouse, 64) - w.quitc = make(chan bool) - } - - if subsys&SubsystemAudio != 0 { - var n int - if n, err = audioInit(AudioFormatStereo44K, 2048); err != nil { - return nil, err - } - println("audio", n) - } - - if subsys&SubsystemVideo != 0 { - go w.readEvents() - } - - return w, nil -} - -func (w *Window) FlushImage() { - if w.Image == nil { - return - } - videoUpdate(w.Image.Linear) -} - -func multimediaInit(subsys int) (err os.Error) { - return os.NewSyscallError("multimedia_init", syscall.MultimediaInit(subsys)) -} - -func videoInit(dx, dy int) (ndx, ndy int, err os.Error) { - if srpcEnabled { - bridge.share.ready = 1 - return int(bridge.share.width), int(bridge.share.height), nil - } - if e := syscall.VideoInit(dx, dy); e != 0 { - return 0, 0, os.NewSyscallError("video_init", int(e)) - } - return dx, dy, nil -} - -func videoUpdate(data []Color) (err os.Error) { - if srpcEnabled { - bridge.flushRPC.Call("upcall", nil) - return - } - return os.NewSyscallError("video_update", syscall.VideoUpdate((*uint32)(&data[0]))) -} - -var noEvents = os.NewError("no events") - -func videoPollEvent(ev []byte) (err os.Error) { - if srpcEnabled { - r := bridge.share.eq.ri - if r == bridge.share.eq.wi { - return noEvents - } - copy(ev, bridge.share.eq.event[r][0:]) - bridge.share.eq.ri = (r + 1) % eqsize - return nil - } - return os.NewSyscallError("video_poll_event", syscall.VideoPollEvent(&ev[0])) -} - -func audioInit(fmt int, want int) (got int, err os.Error) { - var x int - e := syscall.AudioInit(fmt, want, &x) - if e == 0 { - return x, nil - } - return 0, os.NewSyscallError("audio_init", e) -} - -var audioSize uintptr - -// AudioStream provides access to the audio device. -// Each call to AudioStream writes the given data, -// which should be a slice of 16-bit stereo PCM audio samples, -// and returns the number of samples required by the next -// call to AudioStream. -// -// To find out the initial number of samples to write, call AudioStream(nil). -// -func AudioStream(data []uint16) (nextSize int, err os.Error) { - if audioSize == 0 { - e := os.NewSyscallError("audio_stream", syscall.AudioStream(nil, &audioSize)) - return int(audioSize), e - } - if data == nil { - return int(audioSize), nil - } - if uintptr(len(data))*2 != audioSize { - log.Stdoutf("invalid audio size want %d got %d", audioSize, len(data)) - } - e := os.NewSyscallError("audio_stream", syscall.AudioStream(&data[0], &audioSize)) - return int(audioSize), e -} - -// Synchronization structure to wait for bridge to become ready. -var bridge struct { - c chan bool - displayFd int - rpcFd int - share *videoShare - pixel []Color - client *srpc.Client - flushRPC *srpc.RPC -} - -// Wait for bridge to become ready. -// When chan is first created, there is nothing in it, -// so this blocks. Once the bridge is ready, multimediaBridge.Run -// will drop a value into the channel. Then any calls -// to waitBridge will finish, taking the value out and immediately putting it back. -func waitBridge() { bridge.c <- <-bridge.c } - -const eqsize = 64 - -// Data structure shared with host via mmap. -type videoShare struct { - revision int32 // definition below is rev 100 unless noted - mapSize int32 - - // event queue - eq struct { - ri uint32 // read index [0,eqsize) - wi uint32 // write index [0,eqsize) - eof int32 - event [eqsize][64]byte - } - - // now unused - _, _, _, _ int32 - - // video backing store information - width, height, _, size int32 - ready int32 // rev 0x101 -} - -// The frame buffer data is videoShareSize bytes after -// the videoShare begins. -const videoShareSize = 16 * 1024 - -type multimediaBridge struct{} - -// If using SRPC, the runtime will call this method to pass in two file descriptors, -// one to mmap to get the display memory, and another to use for SRPCs back -// to the main process. -func (multimediaBridge) Run(arg, ret []interface{}, size []int) srpc.Errno { - bridge.displayFd = arg[0].(int) - bridge.rpcFd = arg[1].(int) - - var st syscall.Stat_t - if errno := syscall.Fstat(bridge.displayFd, &st); errno != 0 { - log.Exitf("mmbridge stat display: %s", os.Errno(errno)) - } - - addr, _, errno := syscall.Syscall6(syscall.SYS_MMAP, - 0, - uintptr(st.Size), - syscall.PROT_READ|syscall.PROT_WRITE, - syscall.MAP_SHARED, - uintptr(bridge.displayFd), - 0) - if errno != 0 { - log.Exitf("mmap display: %s", os.Errno(errno)) - } - - bridge.share = (*videoShare)(unsafe.Pointer(addr)) - - // Overestimate frame buffer size - // (must use a compile-time constant) - // and then reslice. 256 megapixels (1 GB) should be enough. - fb := (*[256 * 1024 * 1024]Color)(unsafe.Pointer(addr + videoShareSize)) - bridge.pixel = fb[0 : (st.Size-videoShareSize)/4] - - // Configure RPC connection back to client. - var err os.Error - bridge.client, err = srpc.NewClient(bridge.rpcFd) - if err != nil { - log.Exitf("NewClient: %s", err) - } - bridge.flushRPC = bridge.client.NewRPC(nil) - - // Notify waiters that the bridge is ready. - println("bridged", bridge.share.revision) - bridge.c <- true - - return srpc.OK -} - -func init() { - bridge.c = make(chan bool, 1) - if srpcEnabled { - srpc.Add("nacl_multimedia_bridge", "hh:", multimediaBridge{}) - } -} diff --git a/src/pkg/exp/nacl/av/event.go b/src/pkg/exp/nacl/av/event.go deleted file mode 100644 index 11405c980..000000000 --- a/src/pkg/exp/nacl/av/event.go +++ /dev/null @@ -1,472 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// NaCl GUI events. -// Clients do not have raw access to the event stream -// (only filtered through the lens of package draw) -// but perhaps they will. - -package av - -import ( - "encoding/binary" - "exp/draw" - "log" - "os" - "time" -) - -// An eventType identifies the type of a Native Client Event. -type eventType uint8 - -const ( - eventActive = 1 + iota - eventExpose - eventKeyDown - eventKeyUp - eventMouseMotion - eventMouseButtonDown - eventMouseButtonUp - eventQuit - eventUnsupported -) - -// A key represents a key on a keyboard. -type key uint16 - -const ( - keyUnknown = 0 - keyFirst = 0 - keyBackspace = 8 - keyTab = 9 - keyClear = 12 - keyReturn = 13 - keyPause = 19 - keyEscape = 27 - keySpace = 32 - keyExclaim = 33 - keyQuotedbl = 34 - keyHash = 35 - keyDollar = 36 - keyAmpersand = 38 - keyQuote = 39 - keyLeftparen = 40 - keyRightparen = 41 - keyAsterisk = 42 - keyPlus = 43 - keyComma = 44 - keyMinus = 45 - keyPeriod = 46 - keySlash = 47 - key0 = 48 - key1 = 49 - key2 = 50 - key3 = 51 - key4 = 52 - key5 = 53 - key6 = 54 - key7 = 55 - key8 = 56 - key9 = 57 - keyColon = 58 - keySemicolon = 59 - keyLess = 60 - keyEquals = 61 - keyGreater = 62 - keyQuestion = 63 - keyAt = 64 - keyLeftbracket = 91 - keyBackslash = 92 - keyRightbracket = 93 - keyCaret = 94 - keyUnderscore = 95 - keyBackquote = 96 - keyA = 97 - keyB = 98 - keyC = 99 - keyD = 100 - keyE = 101 - keyF = 102 - keyG = 103 - keyH = 104 - keyI = 105 - keyJ = 106 - keyK = 107 - keyL = 108 - keyM = 109 - keyN = 110 - keyO = 111 - keyP = 112 - keyQ = 113 - keyR = 114 - keyS = 115 - keyT = 116 - keyU = 117 - keyV = 118 - keyW = 119 - keyX = 120 - keyY = 121 - keyZ = 122 - keyDelete = 127 - keyWorld0 = 160 - keyWorld1 = 161 - keyWorld2 = 162 - keyWorld3 = 163 - keyWorld4 = 164 - keyWorld5 = 165 - keyWorld6 = 166 - keyWorld7 = 167 - keyWorld8 = 168 - keyWorld9 = 169 - keyWorld10 = 170 - keyWorld11 = 171 - keyWorld12 = 172 - keyWorld13 = 173 - keyWorld14 = 174 - keyWorld15 = 175 - keyWorld16 = 176 - keyWorld17 = 177 - keyWorld18 = 178 - keyWorld19 = 179 - keyWorld20 = 180 - keyWorld21 = 181 - keyWorld22 = 182 - keyWorld23 = 183 - keyWorld24 = 184 - keyWorld25 = 185 - keyWorld26 = 186 - keyWorld27 = 187 - keyWorld28 = 188 - keyWorld29 = 189 - keyWorld30 = 190 - keyWorld31 = 191 - keyWorld32 = 192 - keyWorld33 = 193 - keyWorld34 = 194 - keyWorld35 = 195 - keyWorld36 = 196 - keyWorld37 = 197 - keyWorld38 = 198 - keyWorld39 = 199 - keyWorld40 = 200 - keyWorld41 = 201 - keyWorld42 = 202 - keyWorld43 = 203 - keyWorld44 = 204 - keyWorld45 = 205 - keyWorld46 = 206 - keyWorld47 = 207 - keyWorld48 = 208 - keyWorld49 = 209 - keyWorld50 = 210 - keyWorld51 = 211 - keyWorld52 = 212 - keyWorld53 = 213 - keyWorld54 = 214 - keyWorld55 = 215 - keyWorld56 = 216 - keyWorld57 = 217 - keyWorld58 = 218 - keyWorld59 = 219 - keyWorld60 = 220 - keyWorld61 = 221 - keyWorld62 = 222 - keyWorld63 = 223 - keyWorld64 = 224 - keyWorld65 = 225 - keyWorld66 = 226 - keyWorld67 = 227 - keyWorld68 = 228 - keyWorld69 = 229 - keyWorld70 = 230 - keyWorld71 = 231 - keyWorld72 = 232 - keyWorld73 = 233 - keyWorld74 = 234 - keyWorld75 = 235 - keyWorld76 = 236 - keyWorld77 = 237 - keyWorld78 = 238 - keyWorld79 = 239 - keyWorld80 = 240 - keyWorld81 = 241 - keyWorld82 = 242 - keyWorld83 = 243 - keyWorld84 = 244 - keyWorld85 = 245 - keyWorld86 = 246 - keyWorld87 = 247 - keyWorld88 = 248 - keyWorld89 = 249 - keyWorld90 = 250 - keyWorld91 = 251 - keyWorld92 = 252 - keyWorld93 = 253 - keyWorld94 = 254 - keyWorld95 = 255 - - // Numeric keypad - keyKp0 = 256 - keyKp1 = 257 - keyKp2 = 258 - keyKp3 = 259 - keyKp4 = 260 - keyKp5 = 261 - keyKp6 = 262 - keyKp7 = 263 - keyKp8 = 264 - keyKp9 = 265 - keyKpPeriod = 266 - keyKpDivide = 267 - keyKpMultiply = 268 - keyKpMinus = 269 - keyKpPlus = 270 - keyKpEnter = 271 - keyKpEquals = 272 - - // Arrow & insert/delete pad - keyUp = 273 - keyDown = 274 - keyRight = 275 - keyLeft = 276 - keyInsert = 277 - keyHome = 278 - keyEnd = 279 - keyPageup = 280 - keyPagedown = 281 - - // Function keys - keyF1 = 282 - keyF2 = 283 - keyF3 = 284 - keyF4 = 285 - keyF5 = 286 - keyF6 = 287 - keyF7 = 288 - keyF8 = 289 - keyF9 = 290 - keyF10 = 291 - keyF11 = 292 - keyF12 = 293 - keyF13 = 294 - keyF14 = 295 - keyF15 = 296 - - // Modifier keys - keyNumlock = 300 - keyCapslock = 301 - keyScrollock = 302 - keyRshift = 303 - keyLshift = 304 - keyRctrl = 305 - keyLctrl = 306 - keyRalt = 307 - keyLalt = 308 - keyRmeta = 309 - keyLmeta = 310 - keyLsuper = 311 - keyRsuper = 312 - keyMode = 313 - keyCompose = 314 - - // Misc keys - keyHelp = 315 - keyPrint = 316 - keySysreq = 317 - keyBreak = 318 - keyMenu = 319 - keyPower = 320 - keyEuro = 321 - keyUndo = 322 - - // Add any other keys here - keyLast -) - -// A keymod is a set of bit flags -type keymod uint16 - -const ( - keymodNone = 0x0000 - keymodLshift = 0x0001 - keymodRshift = 0x0002 - keymodLctrl = 0x0040 - keymodRctrl = 0x0080 - keymodLalt = 0x0100 - keymodRalt = 0x0200 - keymodLmeta = 0x0400 - keymodRmeta = 0x0800 - keymodNum = 0x1000 - keymodCaps = 0x2000 - keymodMode = 0x4000 - keymodReserved = 0x8000 -) - -const ( - mouseButtonLeft = 1 - mouseButtonMiddle = 2 - mouseButtonRight = 3 - mouseScrollUp = 4 - mouseScrollDown = 5 -) - -const ( - mouseStateLeftButtonPressed = 1 - mouseStateMiddleButtonPressed = 2 - mouseStateRightButtonPressed = 4 -) - -const ( - activeMouse = 1 // mouse leaving/entering - activeInputFocus = 2 // input focus lost/restored - activeApplication = 4 // application minimized/restored -) - -const maxEventBytes = 64 - -type activeEvent struct { - EventType eventType - Gain uint8 - State uint8 -} - -type exposeEvent struct { - EventType eventType -} - -type keyboardEvent struct { - EventType eventType - Device uint8 - State uint8 - Pad uint8 - ScanCode uint8 - Pad1 uint8 - Key key - Mod keymod - Unicode uint16 -} - -type mouseMotionEvent struct { - EventType eventType - Device uint8 - Buttons uint8 - Pad uint8 - X uint16 - Y uint16 - Xrel int16 - Yrel int16 -} - -type mouseButtonEvent struct { - EventType eventType - Device uint8 - Button uint8 - State uint8 - X uint16 - Y uint16 -} - -type quitEvent struct { - EventType eventType -} - -type syncEvent struct{} - -type event interface{} - -type reader []byte - -func (r *reader) Read(p []byte) (n int, err os.Error) { - b := *r - if len(b) == 0 && len(p) > 0 { - return 0, os.EOF - } - n = copy(p, b) - *r = b[n:] - return -} - -func (w *Window) readEvents() { - buf := make([]byte, maxEventBytes) - clean := false - var ( - ea *activeEvent - ee *exposeEvent - ke *keyboardEvent - mme *mouseMotionEvent - mbe *mouseButtonEvent - qe *quitEvent - ) - var m draw.Mouse - for { - if err := videoPollEvent(buf); err != nil { - if !clean { - clean = w.resizec <- false - } - time.Sleep(10e6) // 10ms - continue - } - clean = false - var e event - switch buf[0] { - default: - log.Stdout("unsupported event type", buf[0]) - continue - case eventActive: - ea = new(activeEvent) - e = ea - case eventExpose: - ee = new(exposeEvent) - e = ee - case eventKeyDown, eventKeyUp: - ke = new(keyboardEvent) - e = ke - case eventMouseMotion: - mme = new(mouseMotionEvent) - e = mme - case eventMouseButtonDown, eventMouseButtonUp: - mbe = new(mouseButtonEvent) - e = mbe - case eventQuit: - qe = new(quitEvent) - e = qe - } - r := reader(buf) - if err := binary.Read(&r, binary.LittleEndian, e); err != nil { - log.Stdout("unpacking %T event: %s", e, err) - continue - } - // log.Stdoutf("%#v\n", e); - switch buf[0] { - case eventExpose: - w.resizec <- true - case eventKeyDown: - w.kbdc <- int(ke.Key) - case eventKeyUp: - w.kbdc <- -int(ke.Key) - case eventMouseMotion: - m.X = int(mme.X) - m.Y = int(mme.Y) - m.Buttons = int(mme.Buttons) - m.Nsec = time.Nanoseconds() - _ = w.mousec <- m - case eventMouseButtonDown: - m.X = int(mbe.X) - m.Y = int(mbe.Y) - // TODO(rsc): Remove uint cast once 8g bug is fixed. - m.Buttons |= 1 << uint(mbe.Button-1) - m.Nsec = time.Nanoseconds() - _ = w.mousec <- m - case eventMouseButtonUp: - m.X = int(mbe.X) - m.Y = int(mbe.Y) - // TODO(rsc): Remove uint cast once 8g bug is fixed. - m.Buttons &^= 1 << uint(mbe.Button-1) - m.Nsec = time.Nanoseconds() - _ = w.mousec <- m - case eventQuit: - w.quitc <- true - } - } -} diff --git a/src/pkg/exp/nacl/av/image.go b/src/pkg/exp/nacl/av/image.go deleted file mode 100644 index 8de531136..000000000 --- a/src/pkg/exp/nacl/av/image.go +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package av - -import ( - "image" -) - -// Native Client image format: -// a single linear array of 32-bit ARGB as packed uint32s. - -// An Image represents a Native Client frame buffer. -// The pixels in the image can be accessed as a single -// linear slice or as a two-dimensional slice of slices. -// Image implements image.Image. -type Image struct { - Linear []Color - Pixel [][]Color -} - -var _ image.Image = (*Image)(nil) - -func (m *Image) ColorModel() image.ColorModel { return ColorModel } - -func (m *Image) Width() int { - if len(m.Pixel) == 0 { - return 0 - } - return len(m.Pixel[0]) -} - -func (m *Image) Height() int { return len(m.Pixel) } - -func (m *Image) At(x, y int) image.Color { return m.Pixel[y][x] } - -func (m *Image) Set(x, y int, color image.Color) { - if c, ok := color.(Color); ok { - m.Pixel[y][x] = c - } - m.Pixel[y][x] = makeColor(color.RGBA()) -} - -func newImage(dx, dy int, linear []Color) *Image { - if linear == nil { - linear = make([]Color, dx*dy) - } - pix := make([][]Color, dy) - for i := range pix { - pix[i] = linear[dx*i : dx*(i+1)] - } - return &Image{linear, pix} -} - -// A Color represents a Native Client color value, -// a 32-bit R, G, B, A value packed as 0xAARRGGBB. -type Color uint32 - -func (p Color) RGBA() (r, g, b, a uint32) { - x := uint32(p) - a = x >> 24 - a |= a << 8 - r = (x >> 16) & 0xFF - r |= r << 8 - g = (x >> 8) & 0xFF - g |= g << 8 - b = x & 0xFF - b |= b << 8 - return -} - -func makeColor(r, g, b, a uint32) Color { - return Color(a>>24<<24 | r>>24<<16 | g>>24<<8 | b>>24) -} - -func toColor(color image.Color) image.Color { - if c, ok := color.(Color); ok { - return c - } - return makeColor(color.RGBA()) -} - -// ColorModel is the color model corresponding to the Native Client Color. -var ColorModel = image.ColorModelFunc(toColor) diff --git a/src/pkg/exp/nacl/srpc/Makefile b/src/pkg/exp/nacl/srpc/Makefile deleted file mode 100644 index 7dda292f5..000000000 --- a/src/pkg/exp/nacl/srpc/Makefile +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -include ../../../../Make.$(GOARCH) - -TARG=exp/nacl/srpc -GOFILES=\ - client.go\ - msg.go\ - server.go\ - -include ../../../../Make.pkg diff --git a/src/pkg/exp/nacl/srpc/client.go b/src/pkg/exp/nacl/srpc/client.go deleted file mode 100644 index f45730ffa..000000000 --- a/src/pkg/exp/nacl/srpc/client.go +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This package implements Native Client's simple RPC (SRPC). -package srpc - -import ( - "bytes" - "log" - "os" - "sync" -) - -// A Client represents the client side of an SRPC connection. -type Client struct { - fd int // fd to server - r msgReceiver - s msgSender - service map[string]srv // services by name - out chan *msg // send to out to write to connection - - mu sync.Mutex // protects pending, idGen - pending map[uint64]*RPC - idGen uint64 // generator for request IDs -} - -// A srv is a single method that the server offers. -type srv struct { - num uint32 // method number - fmt string // argument format -} - -// An RPC represents a single RPC issued by a client. -type RPC struct { - Ret []interface{} // Return values - Done chan *RPC // Channel where notification of done arrives - Errno Errno // Status code - c *Client - id uint64 // request id -} - -// NewClient allocates a new client using the file descriptor fd. -func NewClient(fd int) (c *Client, err os.Error) { - c = new(Client) - c.fd = fd - c.r.fd = fd - c.s.fd = fd - c.service = make(map[string]srv) - c.pending = make(map[uint64]*RPC) - - // service discovery request - m := &msg{ - protocol: protocol, - isReq: true, - Ret: []interface{}{[]byte(nil)}, - Size: []int{4000}, - } - m.packRequest() - c.s.send(m) - m, err = c.r.recv() - if err != nil { - return nil, err - } - m.unpackResponse() - if m.status != OK { - log.Stderrf("NewClient service_discovery: %s", m.status) - return nil, m.status - } - for n, line := range bytes.Split(m.Ret[0].([]byte), []byte{'\n'}, -1) { - i := bytes.Index(line, []byte{':'}) - if i < 0 { - continue - } - c.service[string(line[0:i])] = srv{uint32(n), string(line[i+1:])} - } - - c.out = make(chan *msg) - go c.input() - go c.output() - return c, nil -} - -func (c *Client) input() { - for { - m, err := c.r.recv() - if err != nil { - log.Exitf("client recv: %s", err) - } - if m.unpackResponse(); m.status != OK { - log.Stderrf("invalid message: %s", m.status) - continue - } - c.mu.Lock() - rpc, ok := c.pending[m.requestId] - if ok { - c.pending[m.requestId] = nil, false - } - c.mu.Unlock() - if !ok { - log.Stderrf("unexpected response") - continue - } - rpc.Ret = m.Ret - rpc.Done <- rpc - } -} - -func (c *Client) output() { - for m := range c.out { - c.s.send(m) - } -} - -// NewRPC creates a new RPC on the client connection. -func (c *Client) NewRPC(done chan *RPC) *RPC { - if done == nil { - done = make(chan *RPC) - } - c.mu.Lock() - id := c.idGen - c.idGen++ - c.mu.Unlock() - return &RPC{nil, done, OK, c, id} -} - -// Start issues an RPC request for method name with the given arguments. -// The RPC r must not be in use for another pending request. -// To wait for the RPC to finish, receive from r.Done and then -// inspect r.Ret and r.Errno. -func (r *RPC) Start(name string, arg []interface{}) { - var m msg - - r.Errno = OK - r.c.mu.Lock() - srv, ok := r.c.service[name] - if !ok { - r.c.mu.Unlock() - r.Errno = ErrBadRPCNumber - r.Done <- r - return - } - r.c.pending[r.id] = r - r.c.mu.Unlock() - - m.protocol = protocol - m.requestId = r.id - m.isReq = true - m.rpcNumber = srv.num - m.Arg = arg - - // Fill in the return values and sizes to generate - // the right type chars. We'll take most any size. - - // Skip over input arguments. - // We could check them against arg, but the server - // will do that anyway. - i := 0 - for srv.fmt[i] != ':' { - i++ - } - fmt := srv.fmt[i+1:] - - // Now the return prototypes. - m.Ret = make([]interface{}, len(fmt)-i) - m.Size = make([]int, len(fmt)-i) - for i := 0; i < len(fmt); i++ { - switch fmt[i] { - default: - log.Exitf("unexpected service type %c", fmt[i]) - case 'b': - m.Ret[i] = false - case 'C': - m.Ret[i] = []byte(nil) - m.Size[i] = 1 << 30 - case 'd': - m.Ret[i] = float64(0) - case 'D': - m.Ret[i] = []float64(nil) - m.Size[i] = 1 << 30 - case 'h': - m.Ret[i] = int(-1) - case 'i': - m.Ret[i] = int32(0) - case 'I': - m.Ret[i] = []int32(nil) - m.Size[i] = 1 << 30 - case 's': - m.Ret[i] = "" - m.Size[i] = 1 << 30 - } - } - - m.packRequest() - r.c.out <- &m -} - -// Call is a convenient wrapper that starts the RPC request, -// waits for it to finish, and then returns the results. -// Its implementation is: -// -// r.Start(name, arg) -// <-r.Done -// return r.Ret, r.Errno -// -func (r *RPC) Call(name string, arg []interface{}) (ret []interface{}, err Errno) { - r.Start(name, arg) - <-r.Done - return r.Ret, r.Errno -} diff --git a/src/pkg/exp/nacl/srpc/msg.go b/src/pkg/exp/nacl/srpc/msg.go deleted file mode 100644 index fe36dbdeb..000000000 --- a/src/pkg/exp/nacl/srpc/msg.go +++ /dev/null @@ -1,526 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// SRPC constants, data structures, and parsing. - -package srpc - -import ( - "math" - "os" - "strconv" - "syscall" - "unsafe" -) - -// An Errno is an SRPC status code. -type Errno uint32 - -const ( - OK Errno = 256 + iota - ErrBreak - ErrMessageTruncated - ErrNoMemory - ErrProtocolMismatch - ErrBadRPCNumber - ErrBadArgType - ErrTooFewArgs - ErrTooManyArgs - ErrInArgTypeMismatch - ErrOutArgTypeMismatch - ErrInternalError - ErrAppError -) - -var errstr = [...]string{ - OK - OK: "ok", - ErrBreak - OK: "break", - ErrMessageTruncated - OK: "message truncated", - ErrNoMemory - OK: "out of memory", - ErrProtocolMismatch - OK: "protocol mismatch", - ErrBadRPCNumber - OK: "invalid RPC method number", - ErrBadArgType - OK: "unexpected argument type", - ErrTooFewArgs - OK: "too few arguments", - ErrTooManyArgs - OK: "too many arguments", - ErrInArgTypeMismatch - OK: "input argument type mismatch", - ErrOutArgTypeMismatch - OK: "output argument type mismatch", - ErrInternalError - OK: "internal error", - ErrAppError - OK: "application error", -} - -func (e Errno) String() string { - if e < OK || int(e-OK) >= len(errstr) { - return "Errno(" + strconv.Itoa64(int64(e)) + ")" - } - return errstr[e-OK] -} - -// A *msgHdr is the data argument to the imc_recvmsg -// and imc_sendmsg system calls. Because it contains unchecked -// counts trusted by the system calls, the data structure is unsafe -// to expose to package clients. -type msgHdr struct { - iov *iov - niov int32 - desc *int32 - ndesc int32 - flags uint32 -} - -// A single region for I/O. Just as unsafe as msgHdr. -type iov struct { - base *byte - len int32 -} - -// A msg is the Go representation of a message. -type msg struct { - rdata []byte // data being consumed during message parsing - rdesc []int32 // file descriptors being consumed during message parsing - wdata []byte // data being generated when replying - - // parsed version of message - protocol uint32 - requestId uint64 - isReq bool - rpcNumber uint32 - gotHeader bool - status Errno // error code sent in response - Arg []interface{} // method arguments - Ret []interface{} // method results - Size []int // max sizes for arrays in method results - fmt string // accumulated format string of arg+":"+ret -} - -// A msgReceiver receives messages from a file descriptor. -type msgReceiver struct { - fd int - data [128 * 1024]byte - desc [8]int32 - hdr msgHdr - iov iov -} - -func (r *msgReceiver) recv() (*msg, os.Error) { - // Init pointers to buffers where syscall recvmsg can write. - r.iov.base = &r.data[0] - r.iov.len = int32(len(r.data)) - r.hdr.iov = &r.iov - r.hdr.niov = 1 - r.hdr.desc = &r.desc[0] - r.hdr.ndesc = int32(len(r.desc)) - n, _, e := syscall.Syscall(syscall.SYS_IMC_RECVMSG, uintptr(r.fd), uintptr(unsafe.Pointer(&r.hdr)), 0) - if e != 0 { - return nil, os.NewSyscallError("imc_recvmsg", int(e)) - } - - // Make a copy of the data so that the next recvmsg doesn't - // smash it. The system call did not update r.iov.len. Instead it - // returned the total byte count as n. - m := new(msg) - m.rdata = make([]byte, n) - copy(m.rdata, r.data[0:]) - - // Make a copy of the desc too. - // The system call *did* update r.hdr.ndesc. - if r.hdr.ndesc > 0 { - m.rdesc = make([]int32, r.hdr.ndesc) - for i := range m.rdesc { - m.rdesc[i] = r.desc[i] - } - } - - return m, nil -} - -// A msgSender sends messages on a file descriptor. -type msgSender struct { - fd int - hdr msgHdr - iov iov -} - -func (s *msgSender) send(m *msg) os.Error { - if len(m.wdata) > 0 { - s.iov.base = &m.wdata[0] - } - s.iov.len = int32(len(m.wdata)) - s.hdr.iov = &s.iov - s.hdr.niov = 1 - s.hdr.desc = nil - s.hdr.ndesc = 0 - _, _, e := syscall.Syscall(syscall.SYS_IMC_SENDMSG, uintptr(s.fd), uintptr(unsafe.Pointer(&s.hdr)), 0) - if e != 0 { - return os.NewSyscallError("imc_sendmsg", int(e)) - } - return nil -} - -// Reading from msg.rdata. -func (m *msg) uint8() uint8 { - if m.status != OK { - return 0 - } - if len(m.rdata) < 1 { - m.status = ErrMessageTruncated - return 0 - } - x := m.rdata[0] - m.rdata = m.rdata[1:] - return x -} - -func (m *msg) uint32() uint32 { - if m.status != OK { - return 0 - } - if len(m.rdata) < 4 { - m.status = ErrMessageTruncated - return 0 - } - b := m.rdata[0:4] - x := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 - m.rdata = m.rdata[4:] - return x -} - -func (m *msg) uint64() uint64 { - if m.status != OK { - return 0 - } - if len(m.rdata) < 8 { - m.status = ErrMessageTruncated - return 0 - } - b := m.rdata[0:8] - x := uint64(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24) - x |= uint64(uint32(b[4])|uint32(b[5])<<8|uint32(b[6])<<16|uint32(b[7])<<24) << 32 - m.rdata = m.rdata[8:] - return x -} - -func (m *msg) bytes(n int) []byte { - if m.status != OK { - return nil - } - if len(m.rdata) < n { - m.status = ErrMessageTruncated - return nil - } - x := m.rdata[0:n] - m.rdata = m.rdata[n:] - return x -} - -// Writing to msg.wdata. -func (m *msg) grow(n int) []byte { - i := len(m.wdata) - if i+n > cap(m.wdata) { - a := make([]byte, i, (i+n)*2) - copy(a, m.wdata) - m.wdata = a - } - m.wdata = m.wdata[0 : i+n] - return m.wdata[i : i+n] -} - -func (m *msg) wuint8(x uint8) { m.grow(1)[0] = x } - -func (m *msg) wuint32(x uint32) { - b := m.grow(4) - b[0] = byte(x) - b[1] = byte(x >> 8) - b[2] = byte(x >> 16) - b[3] = byte(x >> 24) -} - -func (m *msg) wuint64(x uint64) { - b := m.grow(8) - lo := uint32(x) - b[0] = byte(lo) - b[1] = byte(lo >> 8) - b[2] = byte(lo >> 16) - b[3] = byte(lo >> 24) - hi := uint32(x >> 32) - b[4] = byte(hi) - b[5] = byte(hi >> 8) - b[6] = byte(hi >> 16) - b[7] = byte(hi >> 24) -} - -func (m *msg) wbytes(p []byte) { copy(m.grow(len(p)), p) } - -func (m *msg) wstring(s string) { - b := m.grow(len(s)) - for i := range b { - b[i] = s[i] - } -} - -// Parsing of RPC header and arguments. -// -// The header format is: -// protocol uint32; -// requestId uint64; -// isReq bool; -// rpcNumber uint32; -// status uint32; // only for response -// -// Then a sequence of values follow, preceded by the length: -// nvalue uint32; -// -// Each value begins with a one-byte type followed by -// type-specific data. -// -// type uint8; -// 'b': x bool; -// 'C': len uint32; x [len]byte; -// 'd': x float64; -// 'D': len uint32; x [len]float64; -// 'h': x int; // handle aka file descriptor -// 'i': x int32; -// 'I': len uint32; x [len]int32; -// 's': len uint32; x [len]byte; -// -// If this is a request, a sequence of pseudo-values follows, -// preceded by its length (nvalue uint32). -// -// Each pseudo-value is a one-byte type as above, -// followed by a maximum length (len uint32) -// for the 'C', 'D', 'I', and 's' types. -// -// In the Go msg, we represent each argument by -// an empty interface containing the type of x in the -// corresponding case. - -// The current protocol number. -const protocol = 0xc0da0002 - -func (m *msg) unpackHeader() { - m.protocol = m.uint32() - m.requestId = m.uint64() - m.isReq = m.uint8() != 0 - m.rpcNumber = m.uint32() - m.gotHeader = m.status == OK // signal that header parsed successfully - if m.gotHeader && !m.isReq { - status := Errno(m.uint32()) - m.gotHeader = m.status == OK // still ok? - if m.gotHeader { - m.status = status - } - } -} - -func (m *msg) packHeader() { - m.wuint32(m.protocol) - m.wuint64(m.requestId) - if m.isReq { - m.wuint8(1) - } else { - m.wuint8(0) - } - m.wuint32(m.rpcNumber) - if !m.isReq { - m.wuint32(uint32(m.status)) - } -} - -func (m *msg) unpackValues(v []interface{}) { - for i := range v { - t := m.uint8() - m.fmt += string(t) - switch t { - default: - if m.status == OK { - m.status = ErrBadArgType - } - return - case 'b': // bool[1] - v[i] = m.uint8() > 0 - case 'C': // char array - v[i] = m.bytes(int(m.uint32())) - case 'd': // double - v[i] = math.Float64frombits(m.uint64()) - case 'D': // double array - a := make([]float64, int(m.uint32())) - for j := range a { - a[j] = math.Float64frombits(m.uint64()) - } - v[i] = a - case 'h': // file descriptor (handle) - if len(m.rdesc) == 0 { - if m.status == OK { - m.status = ErrBadArgType - } - return - } - v[i] = int(m.rdesc[0]) - m.rdesc = m.rdesc[1:] - case 'i': // int - v[i] = int32(m.uint32()) - case 'I': // int array - a := make([]int32, int(m.uint32())) - for j := range a { - a[j] = int32(m.uint32()) - } - v[i] = a - case 's': // string - v[i] = string(m.bytes(int(m.uint32()))) - } - } -} - -func (m *msg) packValues(v []interface{}) { - for i := range v { - switch x := v[i].(type) { - default: - if m.status == OK { - m.status = ErrInternalError - } - return - case bool: - m.wuint8('b') - if x { - m.wuint8(1) - } else { - m.wuint8(0) - } - case []byte: - m.wuint8('C') - m.wuint32(uint32(len(x))) - m.wbytes(x) - case float64: - m.wuint8('d') - m.wuint64(math.Float64bits(x)) - case []float64: - m.wuint8('D') - m.wuint32(uint32(len(x))) - for _, f := range x { - m.wuint64(math.Float64bits(f)) - } - case int32: - m.wuint8('i') - m.wuint32(uint32(x)) - case []int32: - m.wuint8('I') - m.wuint32(uint32(len(x))) - for _, i := range x { - m.wuint32(uint32(i)) - } - case string: - m.wuint8('s') - m.wuint32(uint32(len(x))) - m.wstring(x) - } - } -} - -func (m *msg) unpackRequest() { - m.status = OK - if m.unpackHeader(); m.status != OK { - return - } - if m.protocol != protocol || !m.isReq { - m.status = ErrProtocolMismatch - return - } - - // type-tagged argument values - m.Arg = make([]interface{}, m.uint32()) - m.unpackValues(m.Arg) - if m.status != OK { - return - } - - // type-tagged expected return sizes. - // fill in zero values for each return value - // and save sizes. - m.fmt += ":" - m.Ret = make([]interface{}, m.uint32()) - m.Size = make([]int, len(m.Ret)) - for i := range m.Ret { - t := m.uint8() - m.fmt += string(t) - switch t { - default: - if m.status == OK { - m.status = ErrBadArgType - } - return - case 'b': // bool[1] - m.Ret[i] = false - case 'C': // char array - m.Size[i] = int(m.uint32()) - m.Ret[i] = []byte(nil) - case 'd': // double - m.Ret[i] = float64(0) - case 'D': // double array - m.Size[i] = int(m.uint32()) - m.Ret[i] = []float64(nil) - case 'h': // file descriptor (handle) - m.Ret[i] = int(-1) - case 'i': // int - m.Ret[i] = int32(0) - case 'I': // int array - m.Size[i] = int(m.uint32()) - m.Ret[i] = []int32(nil) - case 's': // string - m.Size[i] = int(m.uint32()) - m.Ret[i] = "" - } - } -} - -func (m *msg) packRequest() { - m.packHeader() - m.wuint32(uint32(len(m.Arg))) - m.packValues(m.Arg) - m.wuint32(uint32(len(m.Ret))) - for i, v := range m.Ret { - switch x := v.(type) { - case bool: - m.wuint8('b') - case []byte: - m.wuint8('C') - m.wuint32(uint32(m.Size[i])) - case float64: - m.wuint8('d') - case []float64: - m.wuint8('D') - m.wuint32(uint32(m.Size[i])) - case int: - m.wuint8('h') - case int32: - m.wuint8('i') - case []int32: - m.wuint8('I') - m.wuint32(uint32(m.Size[i])) - case string: - m.wuint8('s') - m.wuint32(uint32(m.Size[i])) - } - } -} - -func (m *msg) unpackResponse() { - m.status = OK - if m.unpackHeader(); m.status != OK { - return - } - if m.protocol != protocol || m.isReq { - m.status = ErrProtocolMismatch - return - } - - // type-tagged return values - m.fmt = "" - m.Ret = make([]interface{}, m.uint32()) - m.unpackValues(m.Ret) -} - -func (m *msg) packResponse() { - m.packHeader() - m.wuint32(uint32(len(m.Ret))) - m.packValues(m.Ret) -} diff --git a/src/pkg/exp/nacl/srpc/server.go b/src/pkg/exp/nacl/srpc/server.go deleted file mode 100644 index af2b855f5..000000000 --- a/src/pkg/exp/nacl/srpc/server.go +++ /dev/null @@ -1,201 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// SRPC server - -package srpc - -import ( - "bytes" - "log" - "os" - "syscall" -) - -// TODO(rsc): I'd prefer to make this -// type Handler func(m *msg) Errno -// but NaCl can't use closures. -// The explicit interface is a way to attach state. - -// A Handler is a handler for an SRPC method. -// It reads arguments from arg, checks size for array limits, -// writes return values to ret, and returns an Errno status code. -type Handler interface { - Run(arg, ret []interface{}, size []int) Errno -} - -type method struct { - name string - fmt string - handler Handler -} - -var rpcMethod []method - -// BUG(rsc): Add's format string should be replaced by analyzing the -// type of an arbitrary func passed in an interface{} using reflection. - -// Add registers a handler for the named method. -// Fmt is a Native Client format string, a sequence of -// alphabetic characters representing the types of the parameter values, -// a colon, and then a sequence of alphabetic characters -// representing the types of the returned values. -// The format characters and corresponding dynamic types are: -// -// b bool -// C []byte -// d float64 -// D []float64 -// h int // a file descriptor (aka handle) -// i int32 -// I []int32 -// s string -// -func Add(name, fmt string, handler Handler) { - n := len(rpcMethod) - if n >= cap(rpcMethod) { - a := make([]method, n, (n+4)*2) - for i := range a { - a[i] = rpcMethod[i] - } - rpcMethod = a - } - rpcMethod = rpcMethod[0 : n+1] - rpcMethod[n] = method{name, fmt, handler} -} - -// Serve accepts new SRPC connections from the file descriptor fd -// and answers RPCs issued on those connections. -// It closes fd and returns an error if the imc_accept system call fails. -func Serve(fd int) os.Error { - defer syscall.Close(fd) - - for { - cfd, _, e := syscall.Syscall(syscall.SYS_IMC_ACCEPT, uintptr(fd), 0, 0) - if e != 0 { - return os.NewSyscallError("imc_accept", int(e)) - } - go serveLoop(int(cfd)) - } - panic("unreachable") -} - -func serveLoop(fd int) { - c := make(chan *msg) - go sendLoop(fd, c) - - var r msgReceiver - r.fd = fd - for { - m, err := r.recv() - if err != nil { - break - } - m.unpackRequest() - if !m.gotHeader { - log.Stderrf("cannot unpack header: %s", m.status) - continue - } - // log.Stdoutf("<- %#v", m); - m.isReq = false // set up for response - go serveMsg(m, c) - } - close(c) -} - -func sendLoop(fd int, c <-chan *msg) { - var s msgSender - s.fd = fd - for m := range c { - // log.Stdoutf("-> %#v", m); - m.packResponse() - s.send(m) - } - syscall.Close(fd) -} - -func serveMsg(m *msg, c chan<- *msg) { - if m.status != OK { - c <- m - return - } - if m.rpcNumber >= uint32(len(rpcMethod)) { - m.status = ErrBadRPCNumber - c <- m - return - } - - meth := &rpcMethod[m.rpcNumber] - if meth.fmt != m.fmt { - switch { - case len(m.fmt) < len(meth.fmt): - m.status = ErrTooFewArgs - case len(m.fmt) > len(meth.fmt): - m.status = ErrTooManyArgs - default: - // There's a type mismatch. - // It's an in-arg mismatch if the mismatch happens - // before the colon; otherwise it's an out-arg mismatch. - m.status = ErrInArgTypeMismatch - for i := 0; i < len(m.fmt) && m.fmt[i] == meth.fmt[i]; i++ { - if m.fmt[i] == ':' { - m.status = ErrOutArgTypeMismatch - break - } - } - } - c <- m - return - } - - m.status = meth.handler.Run(m.Arg, m.Ret, m.Size) - c <- m -} - -// ServeRuntime serves RPCs issued by the Native Client embedded runtime. -// This should be called by main once all methods have been registered using Add. -func ServeRuntime() os.Error { - // Call getFd to check that we are running embedded. - if _, err := getFd(); err != nil { - return err - } - - // We are running embedded. - // The fd returned by getFd is a red herring. - // Accept connections on magic fd 3. - return Serve(3) -} - -// getFd runs the srpc_get_fd system call. -func getFd() (fd int, err os.Error) { - r1, _, e := syscall.Syscall(syscall.SYS_SRPC_GET_FD, 0, 0, 0) - return int(r1), os.NewSyscallError("srpc_get_fd", int(e)) -} - -// Enabled returns true if SRPC is enabled in the Native Client runtime. -func Enabled() bool { - _, err := getFd() - return err == nil -} - -// Service #0, service_discovery, returns a list of the other services -// and their argument formats. -type serviceDiscovery struct{} - -func (serviceDiscovery) Run(arg, ret []interface{}, size []int) Errno { - var b bytes.Buffer - for _, m := range rpcMethod { - b.WriteString(m.name) - b.WriteByte(':') - b.WriteString(m.fmt) - b.WriteByte('\n') - } - if b.Len() > size[0] { - return ErrNoMemory - } - ret[0] = b.Bytes() - return OK -} - -func init() { Add("service_discovery", ":C", serviceDiscovery{}) } diff --git a/src/pkg/exp/ogle/Makefile b/src/pkg/exp/ogle/Makefile index b701afd9e..ef65d36c8 100644 --- a/src/pkg/exp/ogle/Makefile +++ b/src/pkg/exp/ogle/Makefile @@ -2,7 +2,7 @@ # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. -include ../../../Make.$(GOARCH) +include ../../../Make.inc TARG=exp/ogle GOFILES=\ @@ -23,7 +23,7 @@ CLEANFILES+=ogle include ../../../Make.pkg main.$O: main.go package - $(QUOTED_GOBIN)/$(GC) -I_obj $< + $(GC) -I_obj $< ogle: main.$O - $(QUOTED_GOBIN)/$(LD) -L_obj -o $@ $< + $(LD) -L_obj -o $@ $< diff --git a/src/pkg/exp/ogle/cmd.go b/src/pkg/exp/ogle/cmd.go index 2f087b777..ff137b0f8 100644 --- a/src/pkg/exp/ogle/cmd.go +++ b/src/pkg/exp/ogle/cmd.go @@ -18,6 +18,7 @@ import ( "strings" ) +var fset = token.NewFileSet() var world *eval.World var curProc *Process @@ -43,7 +44,7 @@ func Main() { } // Try line as code - code, err := world.Compile(string(line)) + code, err := world.Compile(fset, string(line)) if err != nil { scanner.PrintError(os.Stderr, err) continue @@ -63,8 +64,7 @@ func Main() { func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) { sc := new(scanner.Scanner) ev := new(scanner.ErrorVector) - sc.Init("input", input, ev, 0) - + sc.Init(fset, "input", input, ev, 0) return sc, ev } @@ -84,8 +84,8 @@ type cmd struct { } var cmds = []cmd{ - cmd{"load", cmdLoad}, - cmd{"bt", cmdBt}, + {"load", cmdLoad}, + {"bt", cmdBt}, } // getCmd attempts to parse an input line as a registered command. If @@ -101,7 +101,7 @@ func getCmd(line []byte) (*cmd, []byte) { slit := string(lit) for i := range cmds { if cmds[i].cmd == slit { - return &cmds[i], line[pos.Offset+len(lit):] + return &cmds[i], line[fset.Position(pos).Offset+len(lit):] } } return nil, nil diff --git a/src/pkg/exp/ogle/process.go b/src/pkg/exp/ogle/process.go index 970a7497a..58e830aa6 100644 --- a/src/pkg/exp/ogle/process.go +++ b/src/pkg/exp/ogle/process.go @@ -390,17 +390,7 @@ func (p *Process) causesToEvents() ([]Event, os.Error) { // postEvent appends an event to the posted queue. These events will // be processed before any currently pending events. func (p *Process) postEvent(ev Event) { - n := len(p.posted) - m := n * 2 - if m == 0 { - m = 4 - } - posted := make([]Event, n+1, m) - for i, p := range p.posted { - posted[i] = p - } - posted[n] = ev - p.posted = posted + p.posted = append(p.posted, ev) } // processEvents processes events in the event queue until no events @@ -452,7 +442,7 @@ func (p *Process) processEvent(ev Event) (EventAction, os.Error) { action, err = p.goroutineExitHook.handle(ev) default: - log.Crashf("Unknown event type %T in queue", p.event) + log.Panicf("Unknown event type %T in queue", p.event) } if err != nil { diff --git a/src/pkg/exp/ogle/rtype.go b/src/pkg/exp/ogle/rtype.go index ce4fdb663..fd77f1bc2 100644 --- a/src/pkg/exp/ogle/rtype.go +++ b/src/pkg/exp/ogle/rtype.go @@ -103,7 +103,7 @@ func newManualType(t eval.Type, arch Arch) *remoteType { rt = &remoteType{t, offset, fieldAlign, mk} default: - log.Crashf("cannot manually construct type %T", t) + log.Panicf("cannot manually construct type %T", t) } typeMap[t] = rt @@ -142,7 +142,7 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType { if sym != nil { name = sym.Name } - log.Stderrf("%sParsing type at %#x (%s)", prtIndent, addr, name) + log.Printf("%sParsing type at %#x (%s)", prtIndent, addr, name) prtIndent += " " defer func() { prtIndent = prtIndent[0 : len(prtIndent)-1] }() } diff --git a/src/pkg/exp/ogle/vars.go b/src/pkg/exp/ogle/vars.go index eed60acec..8a3a14791 100644 --- a/src/pkg/exp/ogle/vars.go +++ b/src/pkg/exp/ogle/vars.go @@ -140,7 +140,7 @@ func (p *Process) populateWorld(w *eval.World) os.Error { // Symbol name name := s.BaseName() if _, ok := pkg[name]; ok { - log.Stderrf("Multiple definitions of symbol %s", s.Name) + log.Printf("Multiple definitions of symbol %s", s.Name) continue } @@ -191,7 +191,7 @@ func (p *Process) populateWorld(w *eval.World) os.Error { err := w.DefineConst(pkgName, pkgType, pkgVal) if err != nil { - log.Stderrf("while defining package %s: %v", pkgName, err) + log.Printf("while defining package %s: %v", pkgName, err) } } diff --git a/src/pkg/exp/spacewar/Makefile b/src/pkg/exp/spacewar/Makefile deleted file mode 100644 index a27e1f969..000000000 --- a/src/pkg/exp/spacewar/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -all: 8.out - -pdp1.8: pdp1.go - 8g pdp1.go - -spacewar.8: spacewar.go code.go pdp1.8 - 8g spacewar.go code.go - -8.out: spacewar.8 - 8l spacewar.8 - -clean: - rm -f *.8 8.out - diff --git a/src/pkg/exp/spacewar/code.go b/src/pkg/exp/spacewar/code.go deleted file mode 100644 index 6391b500a..000000000 --- a/src/pkg/exp/spacewar/code.go +++ /dev/null @@ -1,7556 +0,0 @@ -// This file contains the assembly language and machine code for -// Spacewar!, the original PDP-1 video game. It is downloaded from -// http://spacewar.oversigma.com/sources/sources.zip which has -// the following notice at http://spacewar.oversigma.com/: -// -// Spacewar! was conceived in 1961 by Martin Graetz, Stephen Russell, -// and Wayne Wiitanen. It was first realized on the PDP-1 in 1962 by -// Stephen Russell, Peter Samson, Dan Edwards, and Martin Graetz, -// together with Alan Kotok, Steve Piner, and Robert A Saunders. -// Spacewar! is in the public domain, but this credit paragraph must -// accompany all distributed versions of the program. -// -// This is the original version! Martin Graetz provided us with a -// printed version of the source. We typed in in again - it was about -// 40 pages long - and re-assembled it with a PDP-1 assembler written -// in PERL. The resulting binary runs on a PDP-1 emulator written as -// a Java applet. The code is extremely faithful to the original. There -// are only two changes. 1)The spaceships have been made bigger and -// 2) The overall timing has been special cased to deal with varying -// machine speeds. -// -// The "a", "s", "d", "f" keys control one of the spaceships. The "k", -// "l", ";", "'" keys control the other. The controls are spin one -// way, spin the other, thrust, and fire. -// -// Barry Silverman -// Brian Silverman -// Vadim Gerasimov -// - -package main - -const spacewarCode = ` --/macro fio-dec system, june 1963 - 007652 640500 szm=sza sma-szf - 007652 650500 spq=szm i - 007652 761200 clc=cma+cla-opr -- define senseswitch A -- repeat 3, A=A+A -- szs A -- term -- define init A,B -- law B -- dap A -- term -- define index A,B,C -- idx A -- sas B -- jmp C -- term -- define listen -- cla+cli+clf 1-opr-opr -- szf i 1 -- jmp .-1 -- tyi -- term -- define swap -- rcl 9s -- rcl 9s -- term -- define load A,B -- lio (B -- dio A -- term -- define setup A,B -- law i B -- dac A -- term -- define count A,B -- isp A -- jmp B -- term -- define move A,B -- lio A -- dio B -- term -- define clear A,B -- init .+2, A -- dzm -- index .-1, (dzm B+1, .-1 -- term --/spacewar 3.1 24 sep 62 p1. 1 - 000003 3/ - 000003 600061 jmp sbf / ignore seq. break - 000004 601561 jmp a40 - 000005 601556 jmp a1 / use test word for control, note iot 11 00 --/ interesting and often changed constants --/symb loc usual value (all instructions are executed, --/ and may be replaced by jda or jsp) - 000006 tno, - 000006 6, - 000006 710041 law i 41 / number of torps + 1 - 000007 tvl, - 000007 7, - 000007 675017 sar 4s / torpedo velocity - 000010 rlt, - 000010 10, - 000010 710020 law i 20 / torpedo reload time - 000011 tlf, - 000011 11, - 000011 710140 law i 140 / torpedo life - 000012 foo, - 000012 12, - 000012 757777 -20000 / fuel supply - 000013 maa, - 000013 13, - 000013 000010 10 / spaceship angular acceleration - 000014 sac, - 000014 14, - 000014 675017 sar 4s / spaceship acceleration - 000015 str, - 000015 15, - 000015 000001 1 / star capture radius - 000016 me1, - 000016 16, - 000016 006000 6000 / collision "radius" - 000017 me2, - 000017 17, - 000017 003000 3000 / above/2 - 000020 ddd, - 000020 20, - 000020 777777 777777 / 0 to save space for ddt - 000021 the, - 000021 21, - 000021 675777 sar 9s / amount of torpedo space warpage - 000022 mhs, - 000022 22, - 000022 710010 law i 10 / number of hyperspace shots - 000023 hd1, - 000023 23, - 000023 710040 law i 40 / time in hyperspace before breakout - 000024 hd2, - 000024 24, - 000024 710100 law i 100 / time in hyperspace breakout - 000025 hd3, - 000025 25, - 000025 710200 law i 200 / time to recharge hyperfield generator - 000026 hr1, - 000026 26, - 000026 667777 scl 9s / scale on hyperspatial displacement - 000027 hr2, - 000027 27, - 000027 667017 scl 4s / scale on hyperspatially induced velocity - 000030 hur, - 000030 30, - 000030 040000 40000 / hyperspatial uncertancy - 000031 ran, - 000031 31, - 000031 000000 0 / random number --/ place to build a private control word routine. --/ it should leave the control word in the io as follows. --/ high order 4 bits, rotate ccw, rotate cw, (both mean hyperspace) --/ fire rocket, and fire torpedo. low order 4 bits, same for --/ other ship. routine is entered by jsp cwg. - 000040 40/ - 000040 cwr, - 000040 601672 jmp mg1 / normally iot 11 control - 000061 . 20/ / space --//// --/ routine to flush sequence breaks, if they occur. - 000061 sbf, - 000061 720004 tyi - 000062 220002 lio 2 - 000063 200000 lac 0 - 000064 720054 lsm - 000065 610001 jmp i 1 -- define xincr X,Y,INS -- lac Y -- INS ~ssn -- dac Y -- lac X -- INS ~scn -- dac X -- term -- define yincr X,Y,INS -- lac Y -- INS ~scn -- dac Y -- lac X -- -INS+add+sub ~ssn -- dac X -- term --//// -- define dispatch -- add (a+r -- dap . 1 -- jmp . --a, -- term -- define dispt A,Y,B -- repeat 6, B=B+B -- lio Y -- dpy-A+B -- term -- define scale A,B,C -- lac A -- sar B -- dac C -- term -- define diff V,S,QF -- add i V -- dac i V -- xct QF -- add i S -- dac i S -- term -- define random -- lac ran -- rar 1s -- xor (355760 -- add (355670 -- dac ran -- term -- define ranct S,X,C -- random -- S -- X -- sma -- cma -- dac C -- term --//// --/sine-cosine subroutine. adams associates --/calling sequence= number in ac, jda jda sin or jdacos. --/argument is between q+2 pi, with binary point to right of bit 3. --/anser has binary point to right of bit 0. time = 2.35 ms. -- define mult Z -- jda mpy -- lac Z -- term - 000066 cos, - 000066 000000 0 - 000067 260142 dap csx - 000070 202760 lac (62210 - 000071 400066 add cos - 000072 240074 dac sin - 000073 600077 jmp .+4 - 000074 sin, - 000074 000000 0 - 000075 260142 dap csx - 000076 200074 lac sin - 000077 640200 spa - 000100 si1, - 000100 402761 add (311040 - 000101 422760 sub (62210 - 000102 640400 sma - 000103 600143 jmp si2 - 000104 402760 add (62210 - 000105 si3, - 000105 661003 ral 2s -- mult (242763 -+000106 170171 jda mpy -+000107 202762 lac ZZ11 - 000110 240074 dac sin -- mult sin -+000111 170171 jda mpy -+000112 200074 lac ZZ12 - 000113 240066 dac cos -- mult (756103 -+000114 170171 jda mpy -+000115 202763 lac ZZ13 - 000116 402764 add (121312 -- mult cos -+000117 170171 jda mpy -+000120 200066 lac ZZ14 - 000121 402765 add (532511 -- mult cos -+000122 170171 jda mpy -+000123 200066 lac ZZ15 - 000124 402766 add (144417 -- mult sin -+000125 170171 jda mpy -+000126 200074 lac ZZ16 - 000127 667007 scl 3s - 000130 240066 dac cos - 000131 060074 xor sin - 000132 640400 sma - 000133 600141 jmp csx-1 - 000134 202767 lac (377777 - 000135 220074 lio sin - 000136 642000 spi - 000137 761000 cma - 000140 600142 jmp csx - 000141 200066 lac cos - 000142 csx, - 000142 600142 jmp . - 000143 si2, - 000143 761000 cma - 000144 402760 add (62210 - 000145 640400 sma - 000146 600105 jmp si3 - 000147 402760 add (62210 - 000150 640200 spa - 000151 600154 jmp .+3 - 000152 422760 sub (62210 - 000153 600105 jmp si3 - 000154 422760 sub (62210 - 000155 600100 jmp si1 --//// --/bbn multiply subroutine --/call.. lac one factor, jdy mpy or imp, lac other factor. - 000156 imp, - 000156 000000 0 /returns low 17 bits and sign in ac - 000157 260160 dap im1 - 000160 im1, - 000160 100000 xct - 000161 170171 jda mpy - 000162 200156 lac imp - 000163 440160 idx im1 - 000164 672001 rir 1s - 000165 673777 rcr 9s - 000166 673777 rcr 9s - 000167 610160 jmp i im1 - 000170 mp2, - 000170 000000 0 - 000171 mpy, - 000171 000000 0 /return 34 bits and 2 signs - 000172 260200 dap mp1 - 000173 200171 lac mpy - 000174 640200 spa - 000175 761000 cma - 000176 673777 rcr 9s - 000177 673777 rcr 9s - 000200 mp1, - 000200 100000 xct - 000201 640200 spa - 000202 761000 cma - 000203 240170 dac mp2 - 000204 760200 cla - 000205 540170 mus mp2 -+000206 540170 mus mp2 -+000207 540170 mus mp2 -+000210 540170 mus mp2 -+000211 540170 mus mp2 -+000212 540170 mus mp2 -+000213 540170 mus mp2 -+000214 540170 mus mp2 -+000215 540170 mus mp2 -+000216 540170 mus mp2 -+000217 540170 mus mp2 -+000220 540170 mus mp2 -+000221 540170 mus mp2 -+000222 540170 mus mp2 -+000223 540170 mus mp2 -+000224 540170 mus mp2 -+000225 540170 mus mp2 - 000226 240170 dac mp2 - 000227 100200 xct mp1 - 000230 060171 xor mpy - 000231 640400 sma - 000232 600243 jmp mp3 - 000233 200170 lac mp2 - 000234 761000 cma - 000235 673777 rcr 9s - 000236 673777 rcr 9s - 000237 761000 cma - 000240 673777 rcr 9s - 000241 673777 rcr 9s - 000242 240170 dac mp2 - 000243 mp3, - 000243 440200 idx mp1 - 000244 200170 lac mp2 - 000245 610200 jmp i mp1 --//// --/integer square root --/input in ac, binary point to right of bit 17, jda sqt --/answer in ac with binary point between 8 and 9 --/largest input number = 177777 - 000246 sqt, - 000246 000000 0 - 000247 260260 dap sqx - 000250 710023 law i 23 - 000251 240304 dac sq1 - 000252 340305 dzm sq2 - 000253 220246 lio sqt - 000254 340246 dzm sqt - 000255 sq3, - 000255 460304 isp sq1 - 000256 600261 jmp .+3 - 000257 200305 lac sq2 - 000260 sqx, - 000260 600260 jmp . - 000261 200305 lac sq2 - 000262 665001 sal 1s - 000263 240305 dac sq2 - 000264 200246 lac sqt - 000265 663003 rcl 2s - 000266 650100 sza i - 000267 600255 jmp sq3 - 000270 240246 dac sqt - 000271 200305 lac sq2 - 000272 665001 sal 1s - 000273 402770 add (1 - 000274 420246 sub sqt - 000275 640500 sma+sza-skip - 000276 600255 jmp sq3 - 000277 640200 spa - 000300 761000 cma - 000301 240246 dac sqt - 000302 440305 idx sq2 - 000303 600255 jmp sq3 - 000304 sq1, - 000304 000000 0 - 000305 sq2, - 000305 000000 0 --//// --/bbn divide subroutine --/calling sequence.. lac hi-dividend, lio lo-dividend, jda dvd, lac divisor. --/returns quot in ac, rem in io. - 000306 idv, - 000306 000000 0 /integer divide, dividend in ac. - 000307 260317 dap dv1 - 000310 200306 lac idv - 000311 677777 scr 9s - 000312 677377 scr 8s - 000313 240315 dac dvd - 000314 600317 jmp dv1 - 000315 dvd, - 000315 000000 0 - 000316 260317 dap dv1 - 000317 dv1, - 000317 100000 xct - 000320 640200 spa - 000321 761000 cma - 000322 240306 dac idv - 000323 200315 lac dvd - 000324 640400 sma - 000325 600334 jmp dv2 - 000326 761000 cma - 000327 673777 rcr 9s - 000330 673777 rcr 9s - 000331 761000 cma - 000332 673777 rcr 9s - 000333 673777 rcr 9s - 000334 dv2, - 000334 420306 sub idv - 000335 640400 sma - 000336 600376 jmp dve - 000337 560306 dis idv -+000340 560306 dis idv -+000341 560306 dis idv -+000342 560306 dis idv -+000343 560306 dis idv -+000344 560306 dis idv -+000345 560306 dis idv -+000346 560306 dis idv -+000347 560306 dis idv -+000350 560306 dis idv -+000351 560306 dis idv -+000352 560306 dis idv -+000353 560306 dis idv -+000354 560306 dis idv -+000355 560306 dis idv -+000356 560306 dis idv -+000357 560306 dis idv -+000360 560306 dis idv - 000361 400306 add idv - 000362 320306 dio idv - 000363 764000 cli - 000364 673001 rcr 1s - 000365 220315 lio dvd - 000366 642000 spi - 000367 761000 cma - 000370 240315 dac dvd - 000371 100317 xct dv1 - 000372 060315 xor dvd - 000373 673777 rcr 9s - 000374 673777 rcr 9s - 000375 440317 idx dv1 - 000376 dve, - 000376 440317 idx dv1 - 000377 200306 lac idv - 000400 642000 spi - 000401 761000 cma - 000402 220315 lio dvd - 000403 610317 jmp i dv1 --//// --/outline compiler --/ac=where to compile to, call oc --/ot=address of outline table -- define plinst A -- lac A -- dac i oc -- idx oc -- terminate -- define comtab A, B -- plinst A -- jsp ocs -- lac B -- jmp oce -- terminate - 000404 ocs, - 000404 260411 dap ocz /puts in swap - 000405 330412 dio i oc - 000406 440412 idx oc - 000407 330412 dio i oc - 000410 440412 idx oc - 000411 ocz, - 000411 600411 jmp . - 000412 oc, - 000412 000000 0 - 000413 260554 dap ocx - 000414 210554 lac i ocx - 000415 260434 dap ocg -- plinst (stf 5 -+000416 202771 lac ZZ17 -+000417 250412 dac i oc -+000420 440412 idx oc - 000421 260555 dap ocm - 000422 440554 idx ocx - 000423 ock, -- plinst (lac ~sx1 -+000423 202772 lac ZZ18 -+000424 250412 dac i oc -+000425 440412 idx oc -- plinst (lio ~sy1 -+000426 202773 lac ZZ19 -+000427 250412 dac i oc -+000430 440412 idx oc - 000431 760006 clf 6 - 000432 ocj, -- setup ~occ,6 -+000432 710006 law i ZZ210 -+000433 243112 dac ZZ110 - 000434 ocg, - 000434 220434 lio . - 000435 och, - 000435 760200 cla - 000436 663007 rcl 3s - 000437 323113 dio ~oci - 000440 222774 lio (rcl 9s -- dispatch -+000441 402775 add (a11 -+000442 260443 dap . 1 -+000443 600443 jmp . -+000444 a11, - 000444 760000 opr - 000445 600557 jmp oc1 - 000446 oco, - 000446 600602 jmp oc2 - 000447 ocq, - 000447 600610 jmp oc3 - 000450 ocp, - 000450 600616 jmp oc4 - 000451 ocr, - 000451 600624 jmp oc5 - 000452 600632 jmp oc6 --//// -- plinst (szf 5 //code -+000453 202776 lac ZZ112 -+000454 250412 dac i oc -+000455 440412 idx oc - 000456 402777 add (4 - 000457 260556 dap ocn -- plinst ocn -+000460 200556 lac ZZ113 -+000461 250412 dac i oc -+000462 440412 idx oc -- plinst (dac ~sx1 -+000463 203000 lac ZZ114 -+000464 250412 dac i oc -+000465 440412 idx oc -- plinst (dio ~sy1 -+000466 203001 lac ZZ115 -+000467 250412 dac i oc -+000470 440412 idx oc -- plinst (jmp sq6 -+000471 203002 lac ZZ116 -+000472 250412 dac i oc -+000473 440412 idx oc -- plinst (clf 5 -+000474 203003 lac ZZ117 -+000475 250412 dac i oc -+000476 440412 idx oc -- plinst (lac ~scm -+000477 203004 lac ZZ118 -+000500 250412 dac i oc -+000501 440412 idx oc -- plinst (cma -+000502 203005 lac ZZ119 -+000503 250412 dac i oc -+000504 440412 idx oc -- plinst (dac ~scm -+000505 203006 lac ZZ120 -+000506 250412 dac i oc -+000507 440412 idx oc -- plinst (lac ~ssm -+000510 203007 lac ZZ121 -+000511 250412 dac i oc -+000512 440412 idx oc -- plinst (cma -+000513 203005 lac ZZ122 -+000514 250412 dac i oc -+000515 440412 idx oc -- plinst (dac ~ssm -+000516 203010 lac ZZ123 -+000517 250412 dac i oc -+000520 440412 idx oc -- plinst (lac ~csm -+000521 203011 lac ZZ124 -+000522 250412 dac i oc -+000523 440412 idx oc -- plinst (lio ~ssd -+000524 203012 lac ZZ125 -+000525 250412 dac i oc -+000526 440412 idx oc -- plinst (dac ~ssd -+000527 203013 lac ZZ126 -+000530 250412 dac i oc -+000531 440412 idx oc -- plinst (dio ~csm -+000532 203014 lac ZZ127 -+000533 250412 dac i oc -+000534 440412 idx oc -- plinst (lac ~ssc -+000535 203015 lac ZZ128 -+000536 250412 dac i oc -+000537 440412 idx oc -- plinst (lio ~csn -+000540 203016 lac ZZ129 -+000541 250412 dac i oc -+000542 440412 idx oc -- plinst (dac ~csn -+000543 203017 lac ZZ130 -+000544 250412 dac i oc -+000545 440412 idx oc -- plinst (dio ~ssc -+000546 203020 lac ZZ131 -+000547 250412 dac i oc -+000550 440412 idx oc -- plinst ocm -+000551 200555 lac ZZ132 -+000552 250412 dac i oc -+000553 440412 idx oc - 000554 ocx, - 000554 600554 jmp . - 000555 ocm, - 000555 600555 jmp . - 000556 ocn, - 000556 600556 jmp . - 000557 oc1, -- plinst (add ~ssn -+000557 203021 lac ZZ133 -+000560 250412 dac i oc -+000561 440412 idx oc - 000562 620404 jsp ocs - 000563 203022 lac (sub ~scn - 000564 oce, - 000564 250412 dac i oc - 000565 440412 idx oc - 000566 620404 jsp ocs -- plinst (ioh -+000567 203023 lac ZZ134 -+000570 250412 dac i oc -+000571 440412 idx oc - 000572 203024 lac (dpy-4000 - 000573 ocd, - 000573 250412 dac i oc - 000574 440412 idx oc - 000575 223113 lio ~oci -- count ~occ, och -+000576 463112 isp ZZ135 -+000577 600435 jmp ZZ235 - 000600 440434 idx ocg - 000601 600432 jmp ocj - 000602 oc2, -- comtab (add ~scm, (add ~ssm -- plinst ZZ136 -+000602 203025 lac ZZ137 -+000603 250412 dac i oc -+000604 440412 idx oc -+000605 620404 jsp ocs -+000606 203026 lac ZZ236 -+000607 600564 jmp oce - 000610 oc3, -- comtab (add ~ssc, (sub ~csm -- plinst ZZ138 -+000610 203027 lac ZZ139 -+000611 250412 dac i oc -+000612 440412 idx oc -+000613 620404 jsp ocs -+000614 203030 lac ZZ238 -+000615 600564 jmp oce - 000616 oc4, -- comtab (sub ~scm, (sub ~ssm -- plinst ZZ140 -+000616 203031 lac ZZ141 -+000617 250412 dac i oc -+000620 440412 idx oc -+000621 620404 jsp ocs -+000622 203032 lac ZZ240 -+000623 600564 jmp oce - 000624 oc5, -- comtab (add ~csn, (sub ~ssd -- plinst ZZ142 -+000624 203033 lac ZZ143 -+000625 250412 dac i oc -+000626 440412 idx oc -+000627 620404 jsp ocs -+000630 203034 lac ZZ242 -+000631 600564 jmp oce - 000632 oc6, - 000632 640006 szf 6 - 000633 600642 jmp oc9 - 000634 760016 stf 6 -- plinst (dac ~ssa -+000635 203035 lac ZZ144 -+000636 250412 dac i oc -+000637 440412 idx oc - 000640 203036 lac (dio ~ssi - 000641 600573 jmp ocd - 000642 oc9, - 000642 760006 clf 6 -- plinst (lac ~ssa -+000643 203037 lac ZZ145 -+000644 250412 dac i oc -+000645 440412 idx oc - 000646 203040 lac (lio ~ssi - 000647 600573 jmp ocd --//// --/ display a star -- define starp -- add ~bx -- swap -- add ~by -- swap -- ioh -- dpy-4000 -- terminate -- /star - 000650 blp, - 000650 260675 dap blx - 000651 640060 szs 60 - 000652 600675 jmp blx -- random -+000653 200031 lac ran -+000654 671001 rar 1s -+000655 063041 xor (355760 -+000656 403042 add (355670 -+000657 240031 dac ran - 000660 671777 rar 9s - 000661 023043 and (add 340 - 000662 640200 spa - 000663 062767 xor (377777 - 000664 243116 dac ~bx - 000665 200031 lac ran - 000666 661017 ral 4s - 000667 023043 and (add 340 - 000670 640200 spa - 000671 062767 xor (377777 - 000672 243117 dac ~by - 000673 620676 jsp bpt - 000674 730000 ioh - 000675 blx, - 000675 600675 jmp . - 000676 bpt, - 000676 261117 dap bpx -- random -+000677 200031 lac ran -+000700 671001 rar 1s -+000701 063041 xor (355760 -+000702 403042 add (355670 -+000703 240031 dac ran - 000704 675777 sar 9s - 000705 675037 sar 5s - 000706 640200 spa - 000707 761000 cma - 000710 665007 sal 3s - 000711 403044 add (bds - 000712 260715 dap bjm - 000713 764206 cla cli clf 6-opr-opr - 000714 724007 dpy-4000 - 000715 bjm, - 000715 600715 jmp . - 000716 bds, -- starp -+000716 403116 add ~bx -- swap -+000717 663777 rcl 9s -+000720 663777 rcl 9s -+000721 403117 add ~by -- swap -+000722 663777 rcl 9s -+000723 663777 rcl 9s -+000724 730000 ioh -+000725 724007 dpy-4000 -- starp -+000726 403116 add ~bx -- swap -+000727 663777 rcl 9s -+000730 663777 rcl 9s -+000731 403117 add ~by -- swap -+000732 663777 rcl 9s -+000733 663777 rcl 9s -+000734 730000 ioh -+000735 724007 dpy-4000 -- starp -+000736 403116 add ~bx -- swap -+000737 663777 rcl 9s -+000740 663777 rcl 9s -+000741 403117 add ~by -- swap -+000742 663777 rcl 9s -+000743 663777 rcl 9s -+000744 730000 ioh -+000745 724007 dpy-4000 -- starp -+000746 403116 add ~bx -- swap -+000747 663777 rcl 9s -+000750 663777 rcl 9s -+000751 403117 add ~by -- swap -+000752 663777 rcl 9s -+000753 663777 rcl 9s -+000754 730000 ioh -+000755 724007 dpy-4000 -- starp -+000756 403116 add ~bx -- swap -+000757 663777 rcl 9s -+000760 663777 rcl 9s -+000761 403117 add ~by -- swap -+000762 663777 rcl 9s -+000763 663777 rcl 9s -+000764 730000 ioh -+000765 724007 dpy-4000 -- starp -+000766 403116 add ~bx -- swap -+000767 663777 rcl 9s -+000770 663777 rcl 9s -+000771 403117 add ~by -- swap -+000772 663777 rcl 9s -+000773 663777 rcl 9s -+000774 730000 ioh -+000775 724007 dpy-4000 -- starp -+000776 403116 add ~bx -- swap -+000777 663777 rcl 9s -+001000 663777 rcl 9s -+001001 403117 add ~by -- swap -+001002 663777 rcl 9s -+001003 663777 rcl 9s -+001004 730000 ioh -+001005 724007 dpy-4000 -- starp -+001006 403116 add ~bx -- swap -+001007 663777 rcl 9s -+001010 663777 rcl 9s -+001011 403117 add ~by -- swap -+001012 663777 rcl 9s -+001013 663777 rcl 9s -+001014 730000 ioh -+001015 724007 dpy-4000 -- starp -+001016 403116 add ~bx -- swap -+001017 663777 rcl 9s -+001020 663777 rcl 9s -+001021 403117 add ~by -- swap -+001022 663777 rcl 9s -+001023 663777 rcl 9s -+001024 730000 ioh -+001025 724007 dpy-4000 -- starp -+001026 403116 add ~bx -- swap -+001027 663777 rcl 9s -+001030 663777 rcl 9s -+001031 403117 add ~by -- swap -+001032 663777 rcl 9s -+001033 663777 rcl 9s -+001034 730000 ioh -+001035 724007 dpy-4000 -- starp -+001036 403116 add ~bx -- swap -+001037 663777 rcl 9s -+001040 663777 rcl 9s -+001041 403117 add ~by -- swap -+001042 663777 rcl 9s -+001043 663777 rcl 9s -+001044 730000 ioh -+001045 724007 dpy-4000 -- starp -+001046 403116 add ~bx -- swap -+001047 663777 rcl 9s -+001050 663777 rcl 9s -+001051 403117 add ~by -- swap -+001052 663777 rcl 9s -+001053 663777 rcl 9s -+001054 730000 ioh -+001055 724007 dpy-4000 -- starp -+001056 403116 add ~bx -- swap -+001057 663777 rcl 9s -+001060 663777 rcl 9s -+001061 403117 add ~by -- swap -+001062 663777 rcl 9s -+001063 663777 rcl 9s -+001064 730000 ioh -+001065 724007 dpy-4000 -- starp -+001066 403116 add ~bx -- swap -+001067 663777 rcl 9s -+001070 663777 rcl 9s -+001071 403117 add ~by -- swap -+001072 663777 rcl 9s -+001073 663777 rcl 9s -+001074 730000 ioh -+001075 724007 dpy-4000 -- starp -+001076 403116 add ~bx -- swap -+001077 663777 rcl 9s -+001100 663777 rcl 9s -+001101 403117 add ~by -- swap -+001102 663777 rcl 9s -+001103 663777 rcl 9s -+001104 730000 ioh -+001105 724007 dpy-4000 -- starp -+001106 403116 add ~bx -- swap -+001107 663777 rcl 9s -+001110 663777 rcl 9s -+001111 403117 add ~by -- swap -+001112 663777 rcl 9s -+001113 663777 rcl 9s -+001114 730000 ioh -+001115 724007 dpy-4000 - 001116 640006 szf 6 - 001117 bpx, - 001117 601117 jmp . - 001120 760016 stf 6 - 001121 761000 cma -- swap -+001122 663777 rcl 9s -+001123 663777 rcl 9s - 001124 761000 cma -- swap -+001125 663777 rcl 9s -+001126 663777 rcl 9s - 001127 600715 jmp bjm --//// --/background display . 3/13/62, prs. -- define dislis J, Q, B -- repeat 6, B=B+B -- clf 5 -- lac flo+r -- dap fpo+r --fs, -- dap fin+r -- dap fyn+r -- idx fyn+r --fin, -- lac /lac x -- sub fpr /right margin -- sma -- jmp fgr+r -- add (2000 --frr, -- spq --fou, -- jmp fuu+r --fie, -- sub (1000 -- sal 8s --fyn, -- lio /lio y -- dpy-i+B -- stf 5 --fid, -- idx fyn+r -- sad (lio Q+2 -- jmp flp+r -- sad fpo+r -- jmp fx+r -- dap fin+r -- idx fyn+r -- jmp fin+r --fgr, -- add (2000 -20000 -- jmp frr+r --fuu, -- szf 5 --fx, -- jmp flo+r+1 /return -- idx flo+r -- idx flo+r -- sas (Q+2 -- jmp fid+r -- law J -- dac flo+r -- jmp fid+r --flp, -- lac (lio J -- sad fpo+r -- jmp fx+r -- dap fin+r -- law J+1 -- dap fyn+r -- jmp fin+r --fpo, -- lio --flo, -- J -- terminate --//// -- define background -- jsp bck -- termin - 001130 bck, - 001130 261134 dap bcx - 001131 640040 szs 40 - 001132 601134 jmp bcx - 001133 461441 isp bcc - 001134 bcx, - 001134 601134 jmp . - 001135 710002 law i 2 - 001136 241441 dac bcc -- dislis 1j,1q,3 -+001137 000006 ZZ398=ZZ398+ZZ398 -+001137 000014 ZZ398=ZZ398+ZZ398 -+001137 000030 ZZ398=ZZ398+ZZ398 -+001137 000060 ZZ398=ZZ398+ZZ398 -+001137 000140 ZZ398=ZZ398+ZZ398 -+001137 000300 ZZ398=ZZ398+ZZ398 -+001137 760005 clf 5 -+001140 201214 lac flo98 -+001141 261213 dap fpo98 -+001142 fs98, -+001142 261145 dap fin98 -+001143 261156 dap fyn98 -+001144 441156 idx fyn98 -+001145 fin98, -+001145 200000 lac -+001146 421443 sub fpr -+001147 640400 sma -+001150 601171 jmp fgr98 -+001151 403045 add (2000 -+001152 frr98, -+001152 650500 spq -+001153 fou98, -+001153 601173 jmp fuu98 -+001154 fie98, -+001154 423046 sub (1000 -+001155 665377 sal 8s -+001156 fyn98, -+001156 220000 lio -+001157 720307 dpy-i+ZZ398 -+001160 760015 stf 5 -+001161 fid98, -+001161 441156 idx fyn98 -+001162 503047 sad (lio ZZ298+2 -+001163 601204 jmp flp98 -+001164 501213 sad fpo98 -+001165 601174 jmp fx98 -+001166 261145 dap fin98 -+001167 441156 idx fyn98 -+001170 601145 jmp fin98 -+001171 fgr98, -+001171 403050 add (2000 -20000 -+001172 601152 jmp frr98 -+001173 fuu98, -+001173 640005 szf 5 -+001174 fx98, -+001174 601215 jmp flo98+1 -+001175 441214 idx flo98 -+001176 441214 idx flo98 -+001177 523051 sas (ZZ298+2 -+001200 601161 jmp fid98 -+001201 706000 law ZZ198 -+001202 241214 dac flo98 -+001203 601161 jmp fid98 -+001204 flp98, -+001204 203052 lac (lio ZZ198 -+001205 501213 sad fpo98 -+001206 601174 jmp fx98 -+001207 261145 dap fin98 -+001210 706001 law ZZ198+1 -+001211 261156 dap fyn98 -+001212 601145 jmp fin98 -+001213 fpo98, -+001213 220000 lio -+001214 flo98, -+001214 006000 ZZ198 -- dislis 2j,2q,2 -+001215 000004 ZZ399=ZZ399+ZZ399 -+001215 000010 ZZ399=ZZ399+ZZ399 -+001215 000020 ZZ399=ZZ399+ZZ399 -+001215 000040 ZZ399=ZZ399+ZZ399 -+001215 000100 ZZ399=ZZ399+ZZ399 -+001215 000200 ZZ399=ZZ399+ZZ399 -+001215 760005 clf 5 -+001216 201272 lac flo99 -+001217 261271 dap fpo99 -+001220 fs99, -+001220 261223 dap fin99 -+001221 261234 dap fyn99 -+001222 441234 idx fyn99 -+001223 fin99, -+001223 200000 lac -+001224 421443 sub fpr -+001225 640400 sma -+001226 601247 jmp fgr99 -+001227 403045 add (2000 -+001230 frr99, -+001230 650500 spq -+001231 fou99, -+001231 601251 jmp fuu99 -+001232 fie99, -+001232 423046 sub (1000 -+001233 665377 sal 8s -+001234 fyn99, -+001234 220000 lio -+001235 720207 dpy-i+ZZ399 -+001236 760015 stf 5 -+001237 fid99, -+001237 441234 idx fyn99 -+001240 503053 sad (lio ZZ299+2 -+001241 601262 jmp flp99 -+001242 501271 sad fpo99 -+001243 601252 jmp fx99 -+001244 261223 dap fin99 -+001245 441234 idx fyn99 -+001246 601223 jmp fin99 -+001247 fgr99, -+001247 403050 add (2000 -20000 -+001250 601230 jmp frr99 -+001251 fuu99, -+001251 640005 szf 5 -+001252 fx99, -+001252 601273 jmp flo99+1 -+001253 441272 idx flo99 -+001254 441272 idx flo99 -+001255 523054 sas (ZZ299+2 -+001256 601237 jmp fid99 -+001257 706022 law ZZ199 -+001260 241272 dac flo99 -+001261 601237 jmp fid99 -+001262 flp99, -+001262 203055 lac (lio ZZ199 -+001263 501271 sad fpo99 -+001264 601252 jmp fx99 -+001265 261223 dap fin99 -+001266 706023 law ZZ199+1 -+001267 261234 dap fyn99 -+001270 601223 jmp fin99 -+001271 fpo99, -+001271 220000 lio -+001272 flo99, -+001272 006022 ZZ199 -- dislis 3j,3q,1 -+001273 000002 ZZ3100=ZZ3100+ZZ3100 -+001273 000004 ZZ3100=ZZ3100+ZZ3100 -+001273 000010 ZZ3100=ZZ3100+ZZ3100 -+001273 000020 ZZ3100=ZZ3100+ZZ3100 -+001273 000040 ZZ3100=ZZ3100+ZZ3100 -+001273 000100 ZZ3100=ZZ3100+ZZ3100 -+001273 760005 clf 5 -+001274 201350 lac flo100 -+001275 261347 dap fpo100 -+001276 fs100, -+001276 261301 dap fin100 -+001277 261312 dap fyn100 -+001300 441312 idx fyn100 -+001301 fin100, -+001301 200000 lac -+001302 421443 sub fpr -+001303 640400 sma -+001304 601325 jmp fgr100 -+001305 403045 add (2000 -+001306 frr100, -+001306 650500 spq -+001307 fou100, -+001307 601327 jmp fuu100 -+001310 fie100, -+001310 423046 sub (1000 -+001311 665377 sal 8s -+001312 fyn100, -+001312 220000 lio -+001313 720107 dpy-i+ZZ3100 -+001314 760015 stf 5 -+001315 fid100, -+001315 441312 idx fyn100 -+001316 503056 sad (lio ZZ2100+2 -+001317 601340 jmp flp100 -+001320 501347 sad fpo100 -+001321 601330 jmp fx100 -+001322 261301 dap fin100 -+001323 441312 idx fyn100 -+001324 601301 jmp fin100 -+001325 fgr100, -+001325 403050 add (2000 -20000 -+001326 601306 jmp frr100 -+001327 fuu100, -+001327 640005 szf 5 -+001330 fx100, -+001330 601351 jmp flo100+1 -+001331 441350 idx flo100 -+001332 441350 idx flo100 -+001333 523057 sas (ZZ2100+2 -+001334 601315 jmp fid100 -+001335 706044 law ZZ1100 -+001336 241350 dac flo100 -+001337 601315 jmp fid100 -+001340 flp100, -+001340 203060 lac (lio ZZ1100 -+001341 501347 sad fpo100 -+001342 601330 jmp fx100 -+001343 261301 dap fin100 -+001344 706045 law ZZ1100+1 -+001345 261312 dap fyn100 -+001346 601301 jmp fin100 -+001347 fpo100, -+001347 220000 lio -+001350 flo100, -+001350 006044 ZZ1100 -- dislis 4j,4q,0 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 000000 ZZ3101=ZZ3101+ZZ3101 -+001351 760005 clf 5 -+001352 201426 lac flo101 -+001353 261425 dap fpo101 -+001354 fs101, -+001354 261357 dap fin101 -+001355 261370 dap fyn101 -+001356 441370 idx fyn101 -+001357 fin101, -+001357 200000 lac -+001360 421443 sub fpr -+001361 640400 sma -+001362 601403 jmp fgr101 -+001363 403045 add (2000 -+001364 frr101, -+001364 650500 spq -+001365 fou101, -+001365 601405 jmp fuu101 -+001366 fie101, -+001366 423046 sub (1000 -+001367 665377 sal 8s -+001370 fyn101, -+001370 220000 lio -+001371 720007 dpy-i+ZZ3101 -+001372 760015 stf 5 -+001373 fid101, -+001373 441370 idx fyn101 -+001374 503061 sad (lio ZZ2101+2 -+001375 601416 jmp flp101 -+001376 501425 sad fpo101 -+001377 601406 jmp fx101 -+001400 261357 dap fin101 -+001401 441370 idx fyn101 -+001402 601357 jmp fin101 -+001403 fgr101, -+001403 403050 add (2000 -20000 -+001404 601364 jmp frr101 -+001405 fuu101, -+001405 640005 szf 5 -+001406 fx101, -+001406 601427 jmp flo101+1 -+001407 441426 idx flo101 -+001410 441426 idx flo101 -+001411 523062 sas (ZZ2101+2 -+001412 601373 jmp fid101 -+001413 706306 law ZZ1101 -+001414 241426 dac flo101 -+001415 601373 jmp fid101 -+001416 flp101, -+001416 203063 lac (lio ZZ1101 -+001417 501425 sad fpo101 -+001420 601406 jmp fx101 -+001421 261357 dap fin101 -+001422 706307 law ZZ1101+1 -+001423 261370 dap fyn101 -+001424 601357 jmp fin101 -+001425 fpo101, -+001425 220000 lio -+001426 flo101, -+001426 006306 ZZ1101 - 001427 461442 isp bkc - 001430 601134 jmp bcx - 001431 710020 law i 20 - 001432 241442 dac bkc - 001433 710001 law i 1 - 001434 401443 add fpr - 001435 640200 spa - 001436 403064 add (20000 - 001437 241443 dac fpr - 001440 601134 jmp bcx - 001441 bcc, - 001441 000000 0 - 001442 bkc, - 001442 000000 0 - 001443 fpr, - 001443 010000 10000 --//// --/spacewar 3.1 24 sep 62 pt. 2 --/main control for spaceships - 001444 000030 nob=30 /total number of colliding objects - 001444 ml0, -- load ~mtc, -4000 /delay for loop -+001444 223065 lio (ZZ2102 -+001445 323120 dio ZZ1102 -- init ml1, mtb /loc of calc routines -+001446 703365 law ZZ2103 -+001447 261703 dap ZZ1103 - 001450 403066 add (nob - 001451 261737 dap mx1 /x - 001452 003415 nx1=mtb nob - 001452 403066 add (nob - 001453 261747 dap my1 /y - 001454 003445 ny1=nx1 nob - 001454 403066 add (nob - 001455 261772 dap ma1 / count for length of explosion or torp - 001456 003475 na1=ny1 nob - 001456 403066 add (nob - 001457 262006 dap mb1 / count of instructions taken by calc routine - 001460 003525 nb1=na1 nob - 001460 403066 add (nob - 001461 243121 dac ~mdx / dx - 001462 003555 ndx=nb1 nob - 001462 403066 add (nob - 001463 243122 dac ~mdy / dy - 001464 003605 ndy=ndx nob - 001464 403066 add (nob - 001465 262327 dap mom /angular velocity - 001466 003635 nom=ndy nob - 001466 403067 add (2 - 001467 262343 dap mth / angle - 001470 003637 nth=nom 2 - 001470 403067 add (2 - 001471 243123 dac ~mfu /fuel - 001472 003641 nfu=nth 2 - 001472 403067 add (2 - 001473 243124 dac ~mtr / no torps remaining - 001474 003643 ntr=nfu 2 - 001474 403067 add (2 - 001475 261732 dap mot / outline of spaceship - 001476 003645 not=ntr 2 - 001476 403067 add (2 - 001477 262577 dap mco / old control word - 001500 003647 nco=not 2 - 001500 403067 add (2 - 001501 243125 dac ~mh1 - 001502 003651 nh1=nco 2 - 001502 403067 add (2 - 001503 243126 dac ~mh2 - 001504 003653 nh2=nh1 2 - 001504 403067 add (2 - 001505 243127 dac ~mh3 - 001506 003655 nh3=nh2 2 - 001506 403067 add (2 - 001507 243130 dac ~mh4 - 001510 003657 nh4=nh3 2 - 001510 003661 nnn=nh4 2 --//// - 001510 702310 law ss1 - 001511 063365 xor mtb - 001512 640100 sza - 001513 601534 jmp mdn - 001514 702314 law ss2 - 001515 063366 xor mtb 1 - 001516 640100 sza - 001517 601534 jmp mdn - 001520 700001 law 1 / test if both ships out of torps - 001521 403643 add ntr - 001522 640200 spa - 001523 601530 jmp md1 - 001524 700001 law 1 - 001525 403644 add ntr 1 - 001526 650200 spa i - 001527 601534 jmp mdn - 001530 md1, - 001530 100011 xct tlf / restart delay is 2x torpedo life - 001531 665001 sal 1s - 001532 243131 dac ~ntd - 001533 601703 jmp ml1 - 001534 mdn, -- count ~ntd,ml1 -+001534 463131 isp ZZ1104 -+001535 601703 jmp ZZ2104 - 001536 760011 stf 1 - 001537 760012 stf 2 - 001540 702310 law ss1 - 001541 063365 xor mtb - 001542 640100 sza - 001543 760001 clf 1 - 001544 650100 sza i - 001545 443132 idx ~1sc - 001546 702314 law ss2 - 001547 063366 xor mtb 1 - 001550 640100 sza - 001551 760002 clf 2 - 001552 650100 sza i - 001553 443133 idx ~2sc - 001554 760002 clf 2 - 001555 601564 jmp a --//// - 001556 a1, - 001556 701676 law mg2 / test word control - 001557 243134 dac ~cwg - 001560 601564 jmp a - 001561 a40, - 001561 700040 law cwr / here from start at 4 - 001562 243134 dac ~cwg - 001563 601613 jmp a6 - 001564 a, - 001564 203135 lac ~gct - 001565 640400 sma - 001566 601576 jmp a5 -- count ~gct, a5 -+001567 463135 isp ZZ1105 -+001570 601576 jmp ZZ2105 - 001571 203132 lac ~1sc - 001572 523133 sas ~2sc - 001573 601602 jmp a4 - 001574 710001 law i 1 - 001575 243135 dac ~gct - 001576 a5, - 001576 762200 lat - 001577 023070 and (40 - 001600 650100 sza i - 001601 601621 jmp a2 - 001602 a4, - 001602 203132 lac ~1sc - 001603 223133 lio ~2sc - 001604 760400 hlt - 001605 762200 lat - 001606 023070 and (40 - 001607 640100 sza - 001610 601621 jmp a2 - 001611 343132 dzm ~1sc - 001612 343133 dzm ~2sc - 001613 a6, - 001613 762200 lat - 001614 671077 rar 6s - 001615 023071 and (37 - 001616 640100 sza - 001617 761000 cma - 001620 243135 dac ~gct - 001621 a2, -- clear mtb, nnn-1 / clear out all tables -- init .+2, ZZ1106 -+001621 703365 law ZZ2107 -+001622 261623 dap ZZ1107 -+001623 340000 dzm -- index .-1, (dzm ZZ2106+1, .-1 -+001624 441623 idx ZZ1108 -+001625 523072 sas ZZ2108 -+001626 601623 jmp ZZ3108 - 001627 702310 law ss1 - 001630 243365 dac mtb - 001631 702314 law ss2 - 001632 243366 dac mtb 1 - 001633 203073 lac (200000 - 001634 243415 dac nx1 - 001635 243445 dac ny1 - 001636 761000 cma - 001637 243416 dac nx1 1 - 001640 243446 dac ny1 1 - 001641 203074 lac (144420 - 001642 243637 dac nth --//// - 001643 703661 law nnn / start of outline problem - 001644 243645 dac not - 001645 220020 lio ddd - 001646 652000 spi i - 001647 601652 jmp a3 - 001650 170412 jda oc - 001651 002735 ot1 - 001652 a3, - 001652 243646 dac not 1 - 001653 170412 jda oc - 001654 002746 ot2 - 001655 100006 xct tno - 001656 243643 dac ntr - 001657 243644 dac ntr 1 - 001660 200012 lac foo - 001661 243641 dac nfu - 001662 243642 dac nfu 1 - 001663 702000 law 2000 - 001664 243525 dac nb1 - 001665 243526 dac nb1 1 - 001666 100022 xct mhs - 001667 243653 dac nh2 - 001670 243654 dac nh2 1 - 001671 601444 jmp ml0 --/ control word get routines - 001672 mg1, - 001672 261675 dap mg3 - 001673 764000 cli - 001674 720011 iot 11 - 001675 mg3, - 001675 601675 jmp . - 001676 mg2, - 001676 261702 dap mg4 - 001677 762200 lat -- swap -+001700 663777 rcl 9s -+001701 663777 rcl 9s - 001702 mg4, - 001702 601702 jmp . --//// - 001703 ml1, - 001703 201703 lac . / 1st control word - 001704 650100 sza i / zero if not active - 001705 602011 jmp mq1 / not active -- swap -+001706 663777 rcl 9s -+001707 663777 rcl 9s - 001710 443136 idx ~moc - 001711 642000 spi - 001712 602003 jmp mq4 - 001713 700001 law 1 - 001714 401703 add ml1 - 001715 261734 dap ml2 - 001716 700001 law 1 - 001717 401737 add mx1 - 001720 261740 dap mx2 - 001721 700001 law 1 - 001722 401747 add my1 - 001723 261750 dap my2 - 001724 700001 law 1 - 001725 401772 add ma1 - 001726 261773 dap ma2 - 001727 700001 law 1 - 001730 402006 add mb1 - 001731 261766 dap mb2 - 001732 mot, - 001732 201732 lac . - 001733 262530 dap sp5 - 001734 ml2, - 001734 201734 lac . / 2nd control word - 001735 650500 spq / can it collide? - 001736 601774 jmp mq2 / no - 001737 mx1, - 001737 201737 lac . / calc if collision - 001740 mx2, - 001740 421740 sub . / delta x - 001741 640200 spa / take abs value - 001742 761000 cma - 001743 243137 dac ~mt1 - 001744 420016 sub me1 / < epsilon ? - 001745 640400 sma - 001746 601774 jmp mq2 / no - 001747 my1, - 001747 201747 lac . - 001750 my2, - 001750 421750 sub . - 001751 640200 spa - 001752 761000 cma - 001753 420016 sub me1 / < epsilon ? - 001754 640400 sma - 001755 601774 jmp mq2 / no - 001756 403137 add ~mt1 - 001757 420017 sub me2 - 001760 640400 sma - 001761 601774 jmp mq2 - 001762 203103 lac (mex 400000 / yes, explode - 001763 251703 dac i ml1 / replace calc routine with explosion - 001764 251734 dac i ml2 - 001765 212006 lac i mb1 / duration of explosion - 001766 mb2, - 001766 401766 add . - 001767 761000 cma - 001770 675377 sar 8s - 001771 402770 add (1 - 001772 ma1, - 001772 241772 dac . - 001773 ma2, - 001773 241773 dac . - 001774 mq2, - 001774 441740 idx mx2 / end of comparion loop - 001775 441750 idx my2 - 001776 441773 idx ma2 - 001777 441766 idx mb2 -- index ml2, (lac mtb nob, ml2 -+002000 441734 idx ZZ1111 -+002001 523075 sas ZZ2111 -+002002 601734 jmp ZZ3111 --//// - 002003 mq4, - 002003 211703 lac i ml1 / routine for calculating spaceship - 002004 262005 dap . 1 / or other object and displaying it - 002005 622005 jsp . - 002006 mb1, - 002006 202006 lac . / alter count of number of instructions - 002007 403120 add ~mtc - 002010 243120 dac ~mtc - 002011 mq1, - 002011 441737 idx mx1 / end of comparison and display loop - 002012 441747 idx my1 - 002013 441772 idx ma1 - 002014 442006 idx mb1 - 002015 443121 idx ~mdx - 002016 443122 idx ~mdy - 002017 442327 idx mom - 002020 442343 idx mth - 002021 443140 idx ~mas - 002022 443123 idx ~mfu - 002023 443124 idx ~mtr - 002024 441732 idx mot - 002025 442577 idx mco - 002026 443125 idx ~mh1 - 002027 443126 idx ~mh2 - 002030 443127 idx ~mh3 - 002031 443130 idx ~mh4 -- index ml1, (lac mtb nob-1, ml1 -+002032 441703 idx ZZ1112 -+002033 523076 sas ZZ2112 -+002034 601703 jmp ZZ3112 - 002035 211703 lac i ml1 / display and compute last point - 002036 650100 sza i / if active - 002037 602045 jmp mq3 - 002040 262041 dap . 1 - 002041 622041 jsp . - 002042 212006 lac i mb1 - 002043 403120 add ~mtc - 002044 243120 dac ~mtc - 002045 mq3, -- background / display stars of the heavens -+002045 621130 jsp bck - 002046 620650 jsp blp / display massive star -- count ~mtc, . / use the rest of time of main loop -+002047 463120 isp ZZ1114 -+002050 602047 jmp ZZ2114 - 002051 601444 jmp ml0 / repeat whole works --//// --/ misc calculation routines -- / explosion - 002052 mex, - 002052 262133 dap mxr - 002053 760200 cla -- diff ~mdx, mx1, (sar 3s -+002054 413121 add i ZZ1115 -+002055 253121 dac i ZZ1115 -+002056 103077 xct ZZ3115 -+002057 411737 add i ZZ2115 -+002060 251737 dac i ZZ2115 - 002061 760200 cla -- diff ~mdy, my1, (sar 3s -+002062 413122 add i ZZ1116 -+002063 253122 dac i ZZ1116 -+002064 103077 xct ZZ3116 -+002065 411747 add i ZZ2116 -+002066 251747 dac i ZZ2116 - 002067 702134 law ms2 - 002070 262117 dap msh - 002071 212006 lac i mb1 / time involved - 002072 765000 cma cli-opr - 002073 675007 sar 3s - 002074 243141 dac ~mxc - 002075 ms1, - 002075 423100 sub (140 - 002076 640400 sma - 002077 442117 idx msh - 002100 mz1, -- random -+002100 200031 lac ran -+002101 671001 rar 1s -+002102 063041 xor (355760 -+002103 403042 add (355670 -+002104 240031 dac ran - 002105 023101 and (777 - 002106 043102 ior (scl - 002107 242120 dac mi1 -- random -+002110 200031 lac ran -+002111 671001 rar 1s -+002112 063041 xor (355760 -+002113 403042 add (355670 -+002114 240031 dac ran - 002115 677777 scr 9s - 002116 676777 sir 9s - 002117 msh, - 002117 102117 xct . - 002120 mi1, - 002120 760400 hlt - 002121 411747 add i my1 -- swap -+002122 663777 rcl 9s -+002123 663777 rcl 9s - 002124 411737 add i mx1 - 002125 720307 dpy-i 300 -- count ~mxc, mz1 -+002126 463141 isp ZZ1120 -+002127 602100 jmp ZZ2120 -- count i ma1, mxr -+002130 471772 isp ZZ1121 -+002131 602133 jmp ZZ2121 - 002132 351703 dzm i ml1 - 002133 mxr, - 002133 602133 jmp . - 002134 ms2, - 002134 677001 scr 1s - 002135 677007 scr 3s --/ torpedo calc routine - 002136 tcr, - 002136 262167 dap trc -- count i ma1, tc1 -+002137 471772 isp ZZ1122 -+002140 602146 jmp ZZ2122 - 002141 203103 lac (mex 400000 - 002142 251703 dac i ml1 - 002143 710002 law i 2 - 002144 251772 dac i ma1 - 002145 602167 jmp trc - 002146 tc1, - 002146 211737 lac i mx1 - 002147 675777 sar 9s - 002150 100021 xct the -- diff ~mdy, my1, (sar 3s -+002151 413122 add i ZZ1123 -+002152 253122 dac i ZZ1123 -+002153 103077 xct ZZ3123 -+002154 411747 add i ZZ2123 -+002155 251747 dac i ZZ2123 - 002156 675777 sar 9s - 002157 100021 xct the -- diff ~mdx, mx1, (sar 3s -+002160 413121 add i ZZ1124 -+002161 253121 dac i ZZ1124 -+002162 103077 xct ZZ3124 -+002163 411737 add i ZZ2124 -+002164 251737 dac i ZZ2124 -- dispt i, i my1, 1 -+002165 000002 ZZ3125=ZZ3125+ZZ3125 -+002165 000004 ZZ3125=ZZ3125+ZZ3125 -+002165 000010 ZZ3125=ZZ3125+ZZ3125 -+002165 000020 ZZ3125=ZZ3125+ZZ3125 -+002165 000040 ZZ3125=ZZ3125+ZZ3125 -+002165 000100 ZZ3125=ZZ3125+ZZ3125 -+002165 231747 lio ZZ2125 -+002166 720107 dpy-ZZ1125+ZZ3125 - 002167 trc, - 002167 602167 jmp . --//// --/ hyperspace routines --/ this routine handles a non-colliding ship invisibly --/ in hyperspace - 002170 hp1, - 002170 262245 dap hp2 -- count i ma1, hp2 -+002171 471772 isp ZZ1126 -+002172 602245 jmp ZZ2126 - 002173 702246 law hp3 / next step - 002174 251703 dac i ml1 - 002175 700007 law 7 - 002176 252006 dac i mb1 -- random -+002177 200031 lac ran -+002200 671001 rar 1s -+002201 063041 xor (355760 -+002202 403042 add (355670 -+002203 240031 dac ran - 002204 677777 scr 9s - 002205 676777 sir 9s - 002206 100026 xct hr1 - 002207 411737 add i mx1 - 002210 251737 dac i mx1 -- swap -+002211 663777 rcl 9s -+002212 663777 rcl 9s - 002213 411747 add i my1 - 002214 251747 dac i my1 -- random -+002215 200031 lac ran -+002216 671001 rar 1s -+002217 063041 xor (355760 -+002220 403042 add (355670 -+002221 240031 dac ran - 002222 677777 scr 9s - 002223 676777 sir 9s - 002224 100027 xct hr2 - 002225 253122 dac i ~mdy - 002226 333121 dio i ~mdx -- setup ~hpt,3 -+002227 710003 law i ZZ2130 -+002230 243142 dac ZZ1130 - 002231 200031 lac ran - 002232 252343 dac i mth - 002233 hp4, - 002233 212343 lac i mth - 002234 640400 sma - 002235 422761 sub (311040 - 002236 640200 spa - 002237 402761 add (311040 - 002240 252343 dac i mth -- count ~hpt,hp4 -+002241 463142 isp ZZ1131 -+002242 602233 jmp ZZ2131 - 002243 100024 xct hd2 - 002244 251772 dac i ma1 - 002245 hp2, - 002245 602245 jmp . --/ this routine handles a ship breaking out of --/ hyperspace - 002246 hp3, - 002246 262307 dap hp5 -- count i ma1,hp6 -+002247 471772 isp ZZ1132 -+002250 602304 jmp ZZ2132 - 002251 213125 lac i ~mh1 - 002252 251703 dac i ml1 - 002253 702000 law 2000 - 002254 252006 dac i mb1 -- count i ~mh2,hp7 -+002255 473126 isp ZZ1133 -+002256 602260 jmp ZZ2133 - 002257 353126 dzm i ~mh2 --//// - 002260 hp7, - 002260 100025 xct hd3 - 002261 253127 dac i ~mh3 - 002262 213130 lac i ~mh4 - 002263 400030 add hur - 002264 253130 dac i ~mh4 -- random -+002265 200031 lac ran -+002266 671001 rar 1s -+002267 063041 xor (355760 -+002270 403042 add (355670 -+002271 240031 dac ran - 002272 043104 ior (400000 - 002273 413130 add i ~mh4 - 002274 640200 spa - 002275 602307 jmp hp5 - 002276 203103 lac (mex 400000 - 002277 251703 dac i ml1 - 002300 710010 law i 10 - 002301 251772 dac i ma1 - 002302 702000 law 2000 - 002303 252006 dac i mb1 - 002304 hp6, - 002304 211737 lac i mx1 -- dispt i, i my1, 2 -+002305 000004 ZZ3135=ZZ3135+ZZ3135 -+002305 000010 ZZ3135=ZZ3135+ZZ3135 -+002305 000020 ZZ3135=ZZ3135+ZZ3135 -+002305 000040 ZZ3135=ZZ3135+ZZ3135 -+002305 000100 ZZ3135=ZZ3135+ZZ3135 -+002305 000200 ZZ3135=ZZ3135+ZZ3135 -+002305 231747 lio ZZ2135 -+002306 720207 dpy-ZZ1135+ZZ3135 - 002307 hp5, - 002307 602307 jmp . --//// --/ spaceship calc - 002310 ss1, - 002310 262713 dap srt / first spaceship - 002311 633134 jsp i ~cwg - 002312 323143 dio ~scw - 002313 602320 jmp sr0 - 002314 ss2, - 002314 262713 dap srt - 002315 633134 jsp i ~cwg - 002316 672017 rir 4s - 002317 323143 dio ~scw - 002320 sr0, - 002320 sc1, - 002320 223143 lio ~scw /control word - 002321 760206 clf 6 cla-opr /update angle - 002322 642000 spi - 002323 400013 add maa - 002324 662001 ril 1s - 002325 642000 spi - 002326 420013 sub maa - 002327 mom, - 002327 402327 add . - 002330 252327 dac i mom - 002331 640010 szs 10 - 002332 602335 jmp sr8 - 002333 352327 dzm i mom - 002334 661177 ral 7s - 002335 sr8, - 002335 662001 ril 1s - 002336 642000 spi - 002337 760016 stf 6 - 002340 233123 lio i ~mfu - 002341 652000 spi i - 002342 760006 clf 6 - 002343 mth, - 002343 402343 add . - 002344 640400 sma - 002345 422761 sub (311040 - 002346 640200 spa - 002347 402761 add (311040 - 002350 252343 dac i mth - 002351 170074 jda sin - 002352 243144 dac ~sn - 002353 343116 dzm ~bx - 002354 343117 dzm ~by - 002355 640060 szs 60 - 002356 602430 jmp bsg - 002357 211737 lac i mx1 - 002360 675777 sar 9s - 002361 675003 sar 2s - 002362 243145 dac ~t1 - 002363 170156 jda imp - 002364 203145 lac ~t1 - 002365 243146 dac ~t2 - 002366 211747 lac i my1 --//// - 002367 675777 sar 9s - 002370 675003 sar 2s - 002371 243145 dac ~t1 - 002372 170156 jda imp - 002373 203145 lac ~t1 - 002374 403146 add ~t2 - 002375 420015 sub str - 002376 650500 sma i sza-skp - 002377 602714 jmp poh - 002400 400015 add str - 002401 243145 dac ~t1 - 002402 170246 jda sqt - 002403 675777 sar 9s - 002404 170171 jda mpy - 002405 203145 lac ~t1 - 002406 677003 scr 2s - 002407 650020 szs i 20 / switch 2 for light star - 002410 677003 scr 2s - 002411 640100 sza - 002412 602430 jmp bsg - 002413 323145 dio ~t1 - 002414 211737 lac i mx1 - 002415 761000 cma - 002416 170306 jda idv - 002417 203145 lac ~t1 - 002420 760000 opr - 002421 243116 dac ~bx - 002422 211747 lac i my1 - 002423 761000 cma - 002424 170306 jda idv - 002425 203145 lac ~t1 - 002426 760000 opr - 002427 243117 dac ~by - 002430 bsg, - 002430 760200 cla - 002431 513123 sad i ~mfu - 002432 760006 clf 6 - 002433 212343 lac i mth - 002434 170066 jda cos - 002435 243147 dac ~cs - 002436 675777 sar 9s - 002437 100014 xct sac - 002440 650006 szf i 6 - 002441 760200 cla - 002442 403117 add ~by -- diff ~mdy, my1, (sar 3s -+002443 413122 add i ZZ1136 -+002444 253122 dac i ZZ1136 -+002445 103077 xct ZZ3136 -+002446 411747 add i ZZ2136 -+002447 251747 dac i ZZ2136 - 002450 203144 lac ~sn - 002451 675777 sar 9s - 002452 100014 xct sac - 002453 761000 cma - 002454 650006 szf i 6 - 002455 760200 cla - 002456 403116 add ~bx -- diff ~mdx, mx1, (sar 3s -+002457 413121 add i ZZ1137 -+002460 253121 dac i ZZ1137 -+002461 103077 xct ZZ3137 -+002462 411737 add i ZZ2137 -+002463 251737 dac i ZZ2137 - 002464 sp1, -- scale ~sn, 5s, ~ssn -+002464 203144 lac ZZ1138 -+002465 675037 sar ZZ2138 -+002466 243150 dac ZZ3138 - 002467 sp2, -- scale ~cs, 5s, ~scn -+002467 203147 lac ZZ1139 -+002470 675037 sar ZZ2139 -+002471 243114 dac ZZ3139 - 002472 211737 lac i mx1 --//// - 002473 423150 sub ~ssn - 002474 243151 dac ~sx1 - 002475 423150 sub ~ssn - 002476 243152 dac ~stx - 002477 211747 lac i my1 - 002500 403114 add ~scn - 002501 243153 dac ~sy1 - 002502 403114 add ~scn - 002503 243154 dac ~sty --/ Modified for Smaller Laptop screens - BDS --// scale ~sn, 9s, ~ssn --// scale ~cs, 9s, ~scn -- scale ~sn, 8s, ~ssn -+002504 203144 lac ZZ1140 -+002505 675377 sar ZZ2140 -+002506 243150 dac ZZ3140 -- scale ~cs, 8s, ~scn -+002507 203147 lac ZZ1141 -+002510 675377 sar ZZ2141 -+002511 243114 dac ZZ3141 - 002512 203150 lac ~ssn - 002513 243155 dac ~ssm - 002514 403114 add ~scn - 002515 243156 dac ~ssc - 002516 243157 dac ~ssd - 002517 203150 lac ~ssn - 002520 423114 sub ~scn - 002521 243160 dac ~csn - 002522 761000 cma - 002523 243161 dac ~csm - 002524 203114 lac ~scn - 002525 243162 dac ~scm - 002526 764200 cla cli-opr - 002527 724007 dpy-4000 - 002530 sp5, - 002530 602530 jmp . - 002531 sq6, - 002531 730000 ioh -- ranct sar 9s, sar 4s, ~src -- random -+002532 200031 lac ran -+002533 671001 rar 1s -+002534 063041 xor (355760 -+002535 403042 add (355670 -+002536 240031 dac ran -+002537 675777 ZZ1142 -+002540 675017 ZZ2142 -+002541 640400 sma -+002542 761000 cma -+002543 243163 dac ZZ3142 - 002544 223143 lio ~scw - 002545 662003 ril 2s - 002546 652000 spi i / not blasting - 002547 602574 jmp sq9 / no tail - 002550 sq7, -- scale ~sn, 8s, ~ssn -+002550 203144 lac ZZ1144 -+002551 675377 sar ZZ2144 -+002552 243150 dac ZZ3144 -- scale ~cs, 8s, ~scn -+002553 203147 lac ZZ1145 -+002554 675377 sar ZZ2145 -+002555 243114 dac ZZ3145 -- count i ~mfu, st2 -+002556 473123 isp ZZ1146 -+002557 602562 jmp ZZ2146 - 002560 353123 dzm i ~mfu - 002561 602574 jmp sq9 - 002562 st2, -- yincr ~sx1, ~sy1, sub -+002562 203153 lac ZZ2147 -+002563 423114 ZZ3147 ~scn -+002564 243153 dac ZZ2147 -+002565 203151 lac ZZ1147 -+002566 403150 -ZZ3147+add+sub ~ssn -+002567 243151 dac ZZ1147 -- dispt i, ~sy1 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 000000 ZZ3148=ZZ3148+ZZ3148 -+002570 223153 lio ZZ2148 -+002571 720007 dpy-ZZ1148+ZZ3148 -- count ~src,sq7 -+002572 463163 isp ZZ1149 -+002573 602550 jmp ZZ2149 - 002574 sq9, -- count i ma1, sr5 / check if torp tube reloaded -+002574 471772 isp ZZ1150 -+002575 602667 jmp ZZ2150 - 002576 351772 dzm i ma1 / prevent count around - 002577 mco, - 002577 202577 lac . / previous control word - 002600 761000 cma - 002601 650030 szs i 30 - 002602 761200 clc - 002603 023143 and ~scw / present control word - 002604 661007 ral 3s / torpedo bit to bit 0 - 002605 640400 sma - 002606 602667 jmp sr5 / no launch -- count i ~mtr, st1 / check if torpedos exhausted -+002607 473124 isp ZZ1151 -+002610 602613 jmp ZZ2151 - 002611 353124 dzm i ~mtr / prevent count around - 002612 602667 jmp sr5 - 002613 st1, -- init sr1, mtb / search for unused object -+002613 703365 law ZZ2152 -+002614 262615 dap ZZ1152 - 002615 sr1, - 002615 202615 lac . - 002616 650100 sza i / 0 if unused - 002617 602625 jmp sr2 -- index sr1, (lac mtb+nob, sr1 -+002620 442615 idx ZZ1153 -+002621 523105 sas ZZ2153 -+002622 602615 jmp ZZ3153 - 002623 760400 hlt / no space for new objects - 002624 602623 jmp .-1 --//// - 002625 sr2, - 002625 203106 lac (tcr - 002626 252615 dac i sr1 - 002627 700030 law nob - 002630 402615 add sr1 - 002631 262633 dap ss3 - 002632 223152 lio ~stx - 002633 ss3, - 002633 322633 dio . - 002634 403066 add (nob - 002635 262637 dap ss4 - 002636 223154 lio ~sty - 002637 ss4, - 002637 322637 dio . - 002640 403066 add (nob - 002641 262664 dap sr6 - 002642 403066 add (nob - 002643 262666 dap sr7 - 002644 403066 add (nob - 002645 262654 dap sr3 - 002646 403066 add (nob - 002647 262660 dap sr4 - 002650 203144 lac ~sn - 002651 100007 xct tvl - 002652 761000 cma - 002653 413121 add i ~mdx - 002654 sr3, - 002654 242654 dac . - 002655 203147 lac ~cs - 002656 100007 xct tvl - 002657 413122 add i ~mdy - 002660 sr4, - 002660 242660 dac . - 002661 100010 xct rlt - 002662 251772 dac i ma1 / permit torp tubes to cool - 002663 trp, - 002663 100011 xct tlf / life of torpedo - 002664 sr6, - 002664 242664 dac . - 002665 700020 law 20 - 002666 sr7, - 002666 262666 dap . / length of torp calc - 002667 sr5, -- count i ~mh3, st3 / hyperbutton active? -+002667 473127 isp ZZ1154 -+002670 602713 jmp ZZ2154 - 002671 353127 dzm i ~mh3 - 002672 213126 lac i ~mh2 - 002673 650100 sza i - 002674 602713 jmp st3 - 002675 203143 lac ~scw - 002676 761000 cma - 002677 052577 ior i mco - 002700 023107 and (600000 - 002701 640100 sza - 002702 602713 jmp st3 - 002703 211703 lac i ml1 - 002704 253125 dac i ~mh1 - 002705 203110 lac (hp1 400000 - 002706 251703 dac i ml1 - 002707 100023 xct hd1 - 002710 251772 dac i ma1 - 002711 700003 law 3 - 002712 252006 dac i mb1 - 002713 st3, - 002713 srt, - 002713 602713 jmp . --//// --/ here to handle spaceships into star --/ spaceship in star - 002714 poh, - 002714 353121 dzm i ~mdx - 002715 353122 dzm i ~mdy - 002716 640050 szs 50 - 002717 602730 jmp po1 - 002720 202767 lac (377777 - 002721 251737 dac i mx1 - 002722 251747 dac i my1 - 002723 212006 lac i mb1 - 002724 243150 dac ~ssn -- count ~ssn, . -+002725 463150 isp ZZ1155 -+002726 602725 jmp ZZ2155 - 002727 602713 jmp srt - 002730 po1, - 002730 203103 lac (mex 400000 / now go bang - 002731 251703 dac i ml1 - 002732 710010 law i 10 - 002733 251772 dac i ma1 - 002734 602713 jmp srt --//// --/ outlines of spaceships - 002735 ot1, - 002735 111131 111131 - 002736 111111 111111 - 002737 111111 111111 - 002740 111163 111163 - 002741 311111 311111 - 002742 146111 146111 - 002743 111114 111114 - 002744 700000 700000 - 002745 000005 . 5/ - 002746 ot2, - 002746 013113 013113 - 002747 113111 113111 - 002750 116313 116313 - 002751 131111 131111 - 002752 161151 161151 - 002753 111633 111633 - 002754 365114 365114 - 002755 700000 700000 - 002756 000005 . 5/ - 002757 203164 lac ~ssa / To fix assembler bug - ~ssa only referenced in lit - 002760 constants -+002760 062210 62210 -+002761 311040 311040 -+002762 242763 242763 -+002763 756103 756103 -+002764 121312 121312 -+002765 532511 532511 -+002766 144417 144417 -+002767 377777 377777 -+002770 000001 1 -+002771 760015 stf 5 -+002772 203151 lac ~sx1 -+002773 223153 lio ~sy1 -+002774 663777 rcl 9s -+002775 000444 a11 -+002776 640005 szf 5 -+002777 000004 4 -+003000 243151 dac ~sx1 -+003001 323153 dio ~sy1 -+003002 602531 jmp sq6 -+003003 760005 clf 5 -+003004 203162 lac ~scm -+003005 761000 cma -+003006 243162 dac ~scm -+003007 203155 lac ~ssm -+003010 243155 dac ~ssm -+003011 203161 lac ~csm -+003012 223157 lio ~ssd -+003013 243157 dac ~ssd -+003014 323161 dio ~csm -+003015 203156 lac ~ssc -+003016 223160 lio ~csn -+003017 243160 dac ~csn -+003020 323156 dio ~ssc -+003021 403150 add ~ssn -+003022 423114 sub ~scn -+003023 730000 ioh -+003024 724007 dpy-4000 -+003025 403162 add ~scm -+003026 403155 add ~ssm -+003027 403156 add ~ssc -+003030 423161 sub ~csm -+003031 423162 sub ~scm -+003032 423155 sub ~ssm -+003033 403160 add ~csn -+003034 423157 sub ~ssd -+003035 243164 dac ~ssa -+003036 323115 dio ~ssi -+003037 203164 lac ~ssa -+003040 223115 lio ~ssi -+003041 355760 355760 -+003042 355670 355670 -+003043 400340 add 340 -+003044 000716 bds -+003045 002000 2000 -+003046 001000 1000 -+003047 226022 lio ZZ298+2 -+003050 761777 2000 -20000 -+003051 006022 ZZ298+2 -+003052 226000 lio ZZ198 -+003053 226044 lio ZZ299+2 -+003054 006044 ZZ299+2 -+003055 226022 lio ZZ199 -+003056 226306 lio ZZ2100+2 -+003057 006306 ZZ2100+2 -+003060 226044 lio ZZ1100 -+003061 227652 lio ZZ2101+2 -+003062 007652 ZZ2101+2 -+003063 226306 lio ZZ1101 -+003064 020000 20000 -+003065 773777 ZZ2102 -+003066 000030 nob -+003067 000002 2 -+003070 000040 40 -+003071 000037 37 -+003072 343661 dzm ZZ2106+1 -+003073 200000 200000 -+003074 144420 144420 -+003075 203415 lac mtb nob -+003076 203414 lac mtb nob-1 -+003077 675007 sar 3s -+003100 000140 140 -+003101 000777 777 -+003102 667000 scl -+003103 402052 mex 400000 -+003104 400000 400000 -+003105 203415 lac mtb+nob -+003106 002136 tcr -+003107 600000 600000 -+003110 402170 hp1 400000 - 003111 000000 0 - 003112 variables -+003112 000000 occ -+003113 000000 oci -+003114 000000 scn -+003115 000000 ssi -+003116 000000 bx -+003117 000000 by -+003120 000000 mtc -+003121 000000 mdx -+003122 000000 mdy -+003123 000000 mfu -+003124 000000 mtr -+003125 000000 mh1 -+003126 000000 mh2 -+003127 000000 mh3 -+003130 000000 mh4 -+003131 000000 ntd -+003132 000000 1sc -+003133 000000 2sc -+003134 000000 cwg -+003135 000000 gct -+003136 000000 moc -+003137 000000 mt1 -+003140 000000 mas -+003141 000000 mxc -+003142 000000 hpt -+003143 000000 scw -+003144 000000 sn -+003145 000000 t1 -+003146 000000 t2 -+003147 000000 cs -+003150 000000 ssn -+003151 000000 sx1 -+003152 000000 stx -+003153 000000 sy1 -+003154 000000 sty -+003155 000000 ssm -+003156 000000 ssc -+003157 000000 ssd -+003160 000000 csn -+003161 000000 csm -+003162 000000 scm -+003163 000000 src -+003164 000000 ssa - 003165 p, - 003365 . 200/ / space for patches - 003365 mtb, -- / table of objects and their properties - 006000 6000/ --/stars 1 3/13/62 prs. - 006000 decimal -- define mark X, Y -- repeat 10, Y=Y+Y -- 0 8192 -X -- 0 Y -- terminate - 006000 1j, -- mark 1537, 371 /87 taur, aldebaran -+006000 001346 ZZ2156=ZZ2156+ZZ2156 -+006000 002714 ZZ2156=ZZ2156+ZZ2156 -+006000 005630 ZZ2156=ZZ2156+ZZ2156 -+006000 013460 ZZ2156=ZZ2156+ZZ2156 -+006000 027140 ZZ2156=ZZ2156+ZZ2156 -+006000 056300 ZZ2156=ZZ2156+ZZ2156 -+006000 134600 ZZ2156=ZZ2156+ZZ2156 -+006000 271400 ZZ2156=ZZ2156+ZZ2156 -+006000 014777 0 8192 -ZZ1156 -+006001 271400 0 ZZ2156 -- mark 1762, -189 /19 orio, rigel -+006002 777204 ZZ2157=ZZ2157+ZZ2157 -+006002 776410 ZZ2157=ZZ2157+ZZ2157 -+006002 775020 ZZ2157=ZZ2157+ZZ2157 -+006002 772040 ZZ2157=ZZ2157+ZZ2157 -+006002 764100 ZZ2157=ZZ2157+ZZ2157 -+006002 750200 ZZ2157=ZZ2157+ZZ2157 -+006002 720400 ZZ2157=ZZ2157+ZZ2157 -+006002 641000 ZZ2157=ZZ2157+ZZ2157 -+006002 014436 0 8192 -ZZ1157 -+006003 641000 0 ZZ2157 -- mark 1990, 168 /58 orio, betelgeuze -+006004 000520 ZZ2158=ZZ2158+ZZ2158 -+006004 001240 ZZ2158=ZZ2158+ZZ2158 -+006004 002500 ZZ2158=ZZ2158+ZZ2158 -+006004 005200 ZZ2158=ZZ2158+ZZ2158 -+006004 012400 ZZ2158=ZZ2158+ZZ2158 -+006004 025000 ZZ2158=ZZ2158+ZZ2158 -+006004 052000 ZZ2158=ZZ2158+ZZ2158 -+006004 124000 ZZ2158=ZZ2158+ZZ2158 -+006004 014072 0 8192 -ZZ1158 -+006005 124000 0 ZZ2158 -- mark 2280, -377 /9 cmaj, sirius -+006006 776414 ZZ2159=ZZ2159+ZZ2159 -+006006 775030 ZZ2159=ZZ2159+ZZ2159 -+006006 772060 ZZ2159=ZZ2159+ZZ2159 -+006006 764140 ZZ2159=ZZ2159+ZZ2159 -+006006 750300 ZZ2159=ZZ2159+ZZ2159 -+006006 720600 ZZ2159=ZZ2159+ZZ2159 -+006006 641400 ZZ2159=ZZ2159+ZZ2159 -+006006 503000 ZZ2159=ZZ2159+ZZ2159 -+006006 013430 0 8192 -ZZ1159 -+006007 503000 0 ZZ2159 -- mark 2583, 125 /25 cmin, procyon -+006010 000372 ZZ2160=ZZ2160+ZZ2160 -+006010 000764 ZZ2160=ZZ2160+ZZ2160 -+006010 001750 ZZ2160=ZZ2160+ZZ2160 -+006010 003720 ZZ2160=ZZ2160+ZZ2160 -+006010 007640 ZZ2160=ZZ2160+ZZ2160 -+006010 017500 ZZ2160=ZZ2160+ZZ2160 -+006010 037200 ZZ2160=ZZ2160+ZZ2160 -+006010 076400 ZZ2160=ZZ2160+ZZ2160 -+006010 012751 0 8192 -ZZ1160 -+006011 076400 0 ZZ2160 -- mark 3431, 283 /32 leon, regulus -+006012 001066 ZZ2161=ZZ2161+ZZ2161 -+006012 002154 ZZ2161=ZZ2161+ZZ2161 -+006012 004330 ZZ2161=ZZ2161+ZZ2161 -+006012 010660 ZZ2161=ZZ2161+ZZ2161 -+006012 021540 ZZ2161=ZZ2161+ZZ2161 -+006012 043300 ZZ2161=ZZ2161+ZZ2161 -+006012 106600 ZZ2161=ZZ2161+ZZ2161 -+006012 215400 ZZ2161=ZZ2161+ZZ2161 -+006012 011231 0 8192 -ZZ1161 -+006013 215400 0 ZZ2161 -- mark 4551, -242 /67 virg, spica -+006014 777032 ZZ2162=ZZ2162+ZZ2162 -+006014 776064 ZZ2162=ZZ2162+ZZ2162 -+006014 774150 ZZ2162=ZZ2162+ZZ2162 -+006014 770320 ZZ2162=ZZ2162+ZZ2162 -+006014 760640 ZZ2162=ZZ2162+ZZ2162 -+006014 741500 ZZ2162=ZZ2162+ZZ2162 -+006014 703200 ZZ2162=ZZ2162+ZZ2162 -+006014 606400 ZZ2162=ZZ2162+ZZ2162 -+006014 007071 0 8192 -ZZ1162 -+006015 606400 0 ZZ2162 -- mark 4842, 448 /16 boot, arcturus -+006016 001600 ZZ2163=ZZ2163+ZZ2163 -+006016 003400 ZZ2163=ZZ2163+ZZ2163 -+006016 007000 ZZ2163=ZZ2163+ZZ2163 -+006016 016000 ZZ2163=ZZ2163+ZZ2163 -+006016 034000 ZZ2163=ZZ2163+ZZ2163 -+006016 070000 ZZ2163=ZZ2163+ZZ2163 -+006016 160000 ZZ2163=ZZ2163+ZZ2163 -+006016 340000 ZZ2163=ZZ2163+ZZ2163 -+006016 006426 0 8192 -ZZ1163 -+006017 340000 0 ZZ2163 - 006020 1q, -- mark 6747, 196 /53 aqil, altair -+006020 000610 ZZ2164=ZZ2164+ZZ2164 -+006020 001420 ZZ2164=ZZ2164+ZZ2164 -+006020 003040 ZZ2164=ZZ2164+ZZ2164 -+006020 006100 ZZ2164=ZZ2164+ZZ2164 -+006020 014200 ZZ2164=ZZ2164+ZZ2164 -+006020 030400 ZZ2164=ZZ2164+ZZ2164 -+006020 061000 ZZ2164=ZZ2164+ZZ2164 -+006020 142000 ZZ2164=ZZ2164+ZZ2164 -+006020 002645 0 8192 -ZZ1164 -+006021 142000 0 ZZ2164 - 006022 2j, -- mark 1819, 143 /24 orio, bellatrix -+006022 000436 ZZ2165=ZZ2165+ZZ2165 -+006022 001074 ZZ2165=ZZ2165+ZZ2165 -+006022 002170 ZZ2165=ZZ2165+ZZ2165 -+006022 004360 ZZ2165=ZZ2165+ZZ2165 -+006022 010740 ZZ2165=ZZ2165+ZZ2165 -+006022 021700 ZZ2165=ZZ2165+ZZ2165 -+006022 043600 ZZ2165=ZZ2165+ZZ2165 -+006022 107400 ZZ2165=ZZ2165+ZZ2165 -+006022 014345 0 8192 -ZZ1165 -+006023 107400 0 ZZ2165 -- mark 1884, -29 /46 orio -+006024 777704 ZZ2166=ZZ2166+ZZ2166 -+006024 777610 ZZ2166=ZZ2166+ZZ2166 -+006024 777420 ZZ2166=ZZ2166+ZZ2166 -+006024 777040 ZZ2166=ZZ2166+ZZ2166 -+006024 776100 ZZ2166=ZZ2166+ZZ2166 -+006024 774200 ZZ2166=ZZ2166+ZZ2166 -+006024 770400 ZZ2166=ZZ2166+ZZ2166 -+006024 761000 ZZ2166=ZZ2166+ZZ2166 -+006024 014244 0 8192 -ZZ1166 -+006025 761000 0 ZZ2166 -- mark 1910, -46 /50 orio -+006026 777642 ZZ2167=ZZ2167+ZZ2167 -+006026 777504 ZZ2167=ZZ2167+ZZ2167 -+006026 777210 ZZ2167=ZZ2167+ZZ2167 -+006026 776420 ZZ2167=ZZ2167+ZZ2167 -+006026 775040 ZZ2167=ZZ2167+ZZ2167 -+006026 772100 ZZ2167=ZZ2167+ZZ2167 -+006026 764200 ZZ2167=ZZ2167+ZZ2167 -+006026 750400 ZZ2167=ZZ2167+ZZ2167 -+006026 014212 0 8192 -ZZ1167 -+006027 750400 0 ZZ2167 -- mark 1951, -221 /53 orio -+006030 777104 ZZ2168=ZZ2168+ZZ2168 -+006030 776210 ZZ2168=ZZ2168+ZZ2168 -+006030 774420 ZZ2168=ZZ2168+ZZ2168 -+006030 771040 ZZ2168=ZZ2168+ZZ2168 -+006030 762100 ZZ2168=ZZ2168+ZZ2168 -+006030 744200 ZZ2168=ZZ2168+ZZ2168 -+006030 710400 ZZ2168=ZZ2168+ZZ2168 -+006030 621000 ZZ2168=ZZ2168+ZZ2168 -+006030 014141 0 8192 -ZZ1168 -+006031 621000 0 ZZ2168 -- mark 2152, -407 / 2 cmaj -+006032 776320 ZZ2169=ZZ2169+ZZ2169 -+006032 774640 ZZ2169=ZZ2169+ZZ2169 -+006032 771500 ZZ2169=ZZ2169+ZZ2169 -+006032 763200 ZZ2169=ZZ2169+ZZ2169 -+006032 746400 ZZ2169=ZZ2169+ZZ2169 -+006032 715000 ZZ2169=ZZ2169+ZZ2169 -+006032 632000 ZZ2169=ZZ2169+ZZ2169 -+006032 464000 ZZ2169=ZZ2169+ZZ2169 -+006032 013630 0 8192 -ZZ1169 -+006033 464000 0 ZZ2169 -- mark 2230, 375 /24 gemi -+006034 001356 ZZ2170=ZZ2170+ZZ2170 -+006034 002734 ZZ2170=ZZ2170+ZZ2170 -+006034 005670 ZZ2170=ZZ2170+ZZ2170 -+006034 013560 ZZ2170=ZZ2170+ZZ2170 -+006034 027340 ZZ2170=ZZ2170+ZZ2170 -+006034 056700 ZZ2170=ZZ2170+ZZ2170 -+006034 135600 ZZ2170=ZZ2170+ZZ2170 -+006034 273400 ZZ2170=ZZ2170+ZZ2170 -+006034 013512 0 8192 -ZZ1170 -+006035 273400 0 ZZ2170 -- mark 3201, -187 /30 hyda, alphard -+006036 777210 ZZ2171=ZZ2171+ZZ2171 -+006036 776420 ZZ2171=ZZ2171+ZZ2171 -+006036 775040 ZZ2171=ZZ2171+ZZ2171 -+006036 772100 ZZ2171=ZZ2171+ZZ2171 -+006036 764200 ZZ2171=ZZ2171+ZZ2171 -+006036 750400 ZZ2171=ZZ2171+ZZ2171 -+006036 721000 ZZ2171=ZZ2171+ZZ2171 -+006036 642000 ZZ2171=ZZ2171+ZZ2171 -+006036 011577 0 8192 -ZZ1171 -+006037 642000 0 ZZ2171 -- mark 4005, 344 /94 leon, denebola -+006040 001260 ZZ2172=ZZ2172+ZZ2172 -+006040 002540 ZZ2172=ZZ2172+ZZ2172 -+006040 005300 ZZ2172=ZZ2172+ZZ2172 -+006040 012600 ZZ2172=ZZ2172+ZZ2172 -+006040 025400 ZZ2172=ZZ2172+ZZ2172 -+006040 053000 ZZ2172=ZZ2172+ZZ2172 -+006040 126000 ZZ2172=ZZ2172+ZZ2172 -+006040 254000 ZZ2172=ZZ2172+ZZ2172 -+006040 010133 0 8192 -ZZ1172 -+006041 254000 0 ZZ2172 - 006042 2q, -- mark 5975, 288 /55 ophi -+006042 001100 ZZ2173=ZZ2173+ZZ2173 -+006042 002200 ZZ2173=ZZ2173+ZZ2173 -+006042 004400 ZZ2173=ZZ2173+ZZ2173 -+006042 011000 ZZ2173=ZZ2173+ZZ2173 -+006042 022000 ZZ2173=ZZ2173+ZZ2173 -+006042 044000 ZZ2173=ZZ2173+ZZ2173 -+006042 110000 ZZ2173=ZZ2173+ZZ2173 -+006042 220000 ZZ2173=ZZ2173+ZZ2173 -+006042 004251 0 8192 -ZZ1173 -+006043 220000 0 ZZ2173 - 006044 3j, -- mark 46, 333 /88 pegs, algenib -+006044 001232 ZZ2174=ZZ2174+ZZ2174 -+006044 002464 ZZ2174=ZZ2174+ZZ2174 -+006044 005150 ZZ2174=ZZ2174+ZZ2174 -+006044 012320 ZZ2174=ZZ2174+ZZ2174 -+006044 024640 ZZ2174=ZZ2174+ZZ2174 -+006044 051500 ZZ2174=ZZ2174+ZZ2174 -+006044 123200 ZZ2174=ZZ2174+ZZ2174 -+006044 246400 ZZ2174=ZZ2174+ZZ2174 -+006044 017722 0 8192 -ZZ1174 -+006045 246400 0 ZZ2174 -- mark 362, -244 /31 ceti -+006046 777026 ZZ2175=ZZ2175+ZZ2175 -+006046 776054 ZZ2175=ZZ2175+ZZ2175 -+006046 774130 ZZ2175=ZZ2175+ZZ2175 -+006046 770260 ZZ2175=ZZ2175+ZZ2175 -+006046 760540 ZZ2175=ZZ2175+ZZ2175 -+006046 741300 ZZ2175=ZZ2175+ZZ2175 -+006046 702600 ZZ2175=ZZ2175+ZZ2175 -+006046 605400 ZZ2175=ZZ2175+ZZ2175 -+006046 017226 0 8192 -ZZ1175 -+006047 605400 0 ZZ2175 -- mark 490, 338 /99 pisc -+006050 001244 ZZ2176=ZZ2176+ZZ2176 -+006050 002510 ZZ2176=ZZ2176+ZZ2176 -+006050 005220 ZZ2176=ZZ2176+ZZ2176 -+006050 012440 ZZ2176=ZZ2176+ZZ2176 -+006050 025100 ZZ2176=ZZ2176+ZZ2176 -+006050 052200 ZZ2176=ZZ2176+ZZ2176 -+006050 124400 ZZ2176=ZZ2176+ZZ2176 -+006050 251000 ZZ2176=ZZ2176+ZZ2176 -+006050 017026 0 8192 -ZZ1176 -+006051 251000 0 ZZ2176 -- mark 566, -375 /52 ceti -+006052 776420 ZZ2177=ZZ2177+ZZ2177 -+006052 775040 ZZ2177=ZZ2177+ZZ2177 -+006052 772100 ZZ2177=ZZ2177+ZZ2177 -+006052 764200 ZZ2177=ZZ2177+ZZ2177 -+006052 750400 ZZ2177=ZZ2177+ZZ2177 -+006052 721000 ZZ2177=ZZ2177+ZZ2177 -+006052 642000 ZZ2177=ZZ2177+ZZ2177 -+006052 504000 ZZ2177=ZZ2177+ZZ2177 -+006052 016712 0 8192 -ZZ1177 -+006053 504000 0 ZZ2177 -- mark 621, 462 / 6 arie -+006054 001634 ZZ2178=ZZ2178+ZZ2178 -+006054 003470 ZZ2178=ZZ2178+ZZ2178 -+006054 007160 ZZ2178=ZZ2178+ZZ2178 -+006054 016340 ZZ2178=ZZ2178+ZZ2178 -+006054 034700 ZZ2178=ZZ2178+ZZ2178 -+006054 071600 ZZ2178=ZZ2178+ZZ2178 -+006054 163400 ZZ2178=ZZ2178+ZZ2178 -+006054 347000 ZZ2178=ZZ2178+ZZ2178 -+006054 016623 0 8192 -ZZ1178 -+006055 347000 0 ZZ2178 -- mark 764, -78 /68 ceti, mira -+006056 777542 ZZ2179=ZZ2179+ZZ2179 -+006056 777304 ZZ2179=ZZ2179+ZZ2179 -+006056 776610 ZZ2179=ZZ2179+ZZ2179 -+006056 775420 ZZ2179=ZZ2179+ZZ2179 -+006056 773040 ZZ2179=ZZ2179+ZZ2179 -+006056 766100 ZZ2179=ZZ2179+ZZ2179 -+006056 754200 ZZ2179=ZZ2179+ZZ2179 -+006056 730400 ZZ2179=ZZ2179+ZZ2179 -+006056 016404 0 8192 -ZZ1179 -+006057 730400 0 ZZ2179 -- mark 900, 64 /86 ceti -+006060 000200 ZZ2180=ZZ2180+ZZ2180 -+006060 000400 ZZ2180=ZZ2180+ZZ2180 -+006060 001000 ZZ2180=ZZ2180+ZZ2180 -+006060 002000 ZZ2180=ZZ2180+ZZ2180 -+006060 004000 ZZ2180=ZZ2180+ZZ2180 -+006060 010000 ZZ2180=ZZ2180+ZZ2180 -+006060 020000 ZZ2180=ZZ2180+ZZ2180 -+006060 040000 ZZ2180=ZZ2180+ZZ2180 -+006060 016174 0 8192 -ZZ1180 -+006061 040000 0 ZZ2180 -- mark 1007, 84 /92 ceti -+006062 000250 ZZ2181=ZZ2181+ZZ2181 -+006062 000520 ZZ2181=ZZ2181+ZZ2181 -+006062 001240 ZZ2181=ZZ2181+ZZ2181 -+006062 002500 ZZ2181=ZZ2181+ZZ2181 -+006062 005200 ZZ2181=ZZ2181+ZZ2181 -+006062 012400 ZZ2181=ZZ2181+ZZ2181 -+006062 025000 ZZ2181=ZZ2181+ZZ2181 -+006062 052000 ZZ2181=ZZ2181+ZZ2181 -+006062 016021 0 8192 -ZZ1181 -+006063 052000 0 ZZ2181 -- mark 1243, -230 /23 erid -+006064 777062 ZZ2182=ZZ2182+ZZ2182 -+006064 776144 ZZ2182=ZZ2182+ZZ2182 -+006064 774310 ZZ2182=ZZ2182+ZZ2182 -+006064 770620 ZZ2182=ZZ2182+ZZ2182 -+006064 761440 ZZ2182=ZZ2182+ZZ2182 -+006064 743100 ZZ2182=ZZ2182+ZZ2182 -+006064 706200 ZZ2182=ZZ2182+ZZ2182 -+006064 614400 ZZ2182=ZZ2182+ZZ2182 -+006064 015445 0 8192 -ZZ1182 -+006065 614400 0 ZZ2182 -- mark 1328, -314 /34 erid -+006066 776612 ZZ2183=ZZ2183+ZZ2183 -+006066 775424 ZZ2183=ZZ2183+ZZ2183 -+006066 773050 ZZ2183=ZZ2183+ZZ2183 -+006066 766120 ZZ2183=ZZ2183+ZZ2183 -+006066 754240 ZZ2183=ZZ2183+ZZ2183 -+006066 730500 ZZ2183=ZZ2183+ZZ2183 -+006066 661200 ZZ2183=ZZ2183+ZZ2183 -+006066 542400 ZZ2183=ZZ2183+ZZ2183 -+006066 015320 0 8192 -ZZ1183 -+006067 542400 0 ZZ2183 -- mark 1495, 432 /74 taur -+006070 001540 ZZ2184=ZZ2184+ZZ2184 -+006070 003300 ZZ2184=ZZ2184+ZZ2184 -+006070 006600 ZZ2184=ZZ2184+ZZ2184 -+006070 015400 ZZ2184=ZZ2184+ZZ2184 -+006070 033000 ZZ2184=ZZ2184+ZZ2184 -+006070 066000 ZZ2184=ZZ2184+ZZ2184 -+006070 154000 ZZ2184=ZZ2184+ZZ2184 -+006070 330000 ZZ2184=ZZ2184+ZZ2184 -+006070 015051 0 8192 -ZZ1184 -+006071 330000 0 ZZ2184 -- mark 1496, 356 /78 taur -+006072 001310 ZZ2185=ZZ2185+ZZ2185 -+006072 002620 ZZ2185=ZZ2185+ZZ2185 -+006072 005440 ZZ2185=ZZ2185+ZZ2185 -+006072 013100 ZZ2185=ZZ2185+ZZ2185 -+006072 026200 ZZ2185=ZZ2185+ZZ2185 -+006072 054400 ZZ2185=ZZ2185+ZZ2185 -+006072 131000 ZZ2185=ZZ2185+ZZ2185 -+006072 262000 ZZ2185=ZZ2185+ZZ2185 -+006072 015050 0 8192 -ZZ1185 -+006073 262000 0 ZZ2185 -- mark 1618, 154 / 1 orio -+006074 000464 ZZ2186=ZZ2186+ZZ2186 -+006074 001150 ZZ2186=ZZ2186+ZZ2186 -+006074 002320 ZZ2186=ZZ2186+ZZ2186 -+006074 004640 ZZ2186=ZZ2186+ZZ2186 -+006074 011500 ZZ2186=ZZ2186+ZZ2186 -+006074 023200 ZZ2186=ZZ2186+ZZ2186 -+006074 046400 ZZ2186=ZZ2186+ZZ2186 -+006074 115000 ZZ2186=ZZ2186+ZZ2186 -+006074 014656 0 8192 -ZZ1186 -+006075 115000 0 ZZ2186 -- mark 1644, 52 / 8 orio -+006076 000150 ZZ2187=ZZ2187+ZZ2187 -+006076 000320 ZZ2187=ZZ2187+ZZ2187 -+006076 000640 ZZ2187=ZZ2187+ZZ2187 -+006076 001500 ZZ2187=ZZ2187+ZZ2187 -+006076 003200 ZZ2187=ZZ2187+ZZ2187 -+006076 006400 ZZ2187=ZZ2187+ZZ2187 -+006076 015000 ZZ2187=ZZ2187+ZZ2187 -+006076 032000 ZZ2187=ZZ2187+ZZ2187 -+006076 014624 0 8192 -ZZ1187 -+006077 032000 0 ZZ2187 -- mark 1723, -119 /67 erid -+006100 777420 ZZ2188=ZZ2188+ZZ2188 -+006100 777040 ZZ2188=ZZ2188+ZZ2188 -+006100 776100 ZZ2188=ZZ2188+ZZ2188 -+006100 774200 ZZ2188=ZZ2188+ZZ2188 -+006100 770400 ZZ2188=ZZ2188+ZZ2188 -+006100 761000 ZZ2188=ZZ2188+ZZ2188 -+006100 742000 ZZ2188=ZZ2188+ZZ2188 -+006100 704000 ZZ2188=ZZ2188+ZZ2188 -+006100 014505 0 8192 -ZZ1188 -+006101 704000 0 ZZ2188 -- mark 1755, -371 / 5 leps -+006102 776430 ZZ2189=ZZ2189+ZZ2189 -+006102 775060 ZZ2189=ZZ2189+ZZ2189 -+006102 772140 ZZ2189=ZZ2189+ZZ2189 -+006102 764300 ZZ2189=ZZ2189+ZZ2189 -+006102 750600 ZZ2189=ZZ2189+ZZ2189 -+006102 721400 ZZ2189=ZZ2189+ZZ2189 -+006102 643000 ZZ2189=ZZ2189+ZZ2189 -+006102 506000 ZZ2189=ZZ2189+ZZ2189 -+006102 014445 0 8192 -ZZ1189 -+006103 506000 0 ZZ2189 -- mark 1779, -158 /20 orio -+006104 777302 ZZ2190=ZZ2190+ZZ2190 -+006104 776604 ZZ2190=ZZ2190+ZZ2190 -+006104 775410 ZZ2190=ZZ2190+ZZ2190 -+006104 773020 ZZ2190=ZZ2190+ZZ2190 -+006104 766040 ZZ2190=ZZ2190+ZZ2190 -+006104 754100 ZZ2190=ZZ2190+ZZ2190 -+006104 730200 ZZ2190=ZZ2190+ZZ2190 -+006104 660400 ZZ2190=ZZ2190+ZZ2190 -+006104 014415 0 8192 -ZZ1190 -+006105 660400 0 ZZ2190 -- mark 1817, -57 /28 orio -+006106 777614 ZZ2191=ZZ2191+ZZ2191 -+006106 777430 ZZ2191=ZZ2191+ZZ2191 -+006106 777060 ZZ2191=ZZ2191+ZZ2191 -+006106 776140 ZZ2191=ZZ2191+ZZ2191 -+006106 774300 ZZ2191=ZZ2191+ZZ2191 -+006106 770600 ZZ2191=ZZ2191+ZZ2191 -+006106 761400 ZZ2191=ZZ2191+ZZ2191 -+006106 743000 ZZ2191=ZZ2191+ZZ2191 -+006106 014347 0 8192 -ZZ1191 -+006107 743000 0 ZZ2191 -- mark 1843, -474 / 9 leps -+006110 776112 ZZ2192=ZZ2192+ZZ2192 -+006110 774224 ZZ2192=ZZ2192+ZZ2192 -+006110 770450 ZZ2192=ZZ2192+ZZ2192 -+006110 761120 ZZ2192=ZZ2192+ZZ2192 -+006110 742240 ZZ2192=ZZ2192+ZZ2192 -+006110 704500 ZZ2192=ZZ2192+ZZ2192 -+006110 611200 ZZ2192=ZZ2192+ZZ2192 -+006110 422400 ZZ2192=ZZ2192+ZZ2192 -+006110 014315 0 8192 -ZZ1192 -+006111 422400 0 ZZ2192 -- mark 1860, -8 /34 orio -+006112 777756 ZZ2193=ZZ2193+ZZ2193 -+006112 777734 ZZ2193=ZZ2193+ZZ2193 -+006112 777670 ZZ2193=ZZ2193+ZZ2193 -+006112 777560 ZZ2193=ZZ2193+ZZ2193 -+006112 777340 ZZ2193=ZZ2193+ZZ2193 -+006112 776700 ZZ2193=ZZ2193+ZZ2193 -+006112 775600 ZZ2193=ZZ2193+ZZ2193 -+006112 773400 ZZ2193=ZZ2193+ZZ2193 -+006112 014274 0 8192 -ZZ1193 -+006113 773400 0 ZZ2193 -- mark 1868, -407 /11 leps -+006114 776320 ZZ2194=ZZ2194+ZZ2194 -+006114 774640 ZZ2194=ZZ2194+ZZ2194 -+006114 771500 ZZ2194=ZZ2194+ZZ2194 -+006114 763200 ZZ2194=ZZ2194+ZZ2194 -+006114 746400 ZZ2194=ZZ2194+ZZ2194 -+006114 715000 ZZ2194=ZZ2194+ZZ2194 -+006114 632000 ZZ2194=ZZ2194+ZZ2194 -+006114 464000 ZZ2194=ZZ2194+ZZ2194 -+006114 014264 0 8192 -ZZ1194 -+006115 464000 0 ZZ2194 -- mark 1875, 225 /39 orio -+006116 000702 ZZ2195=ZZ2195+ZZ2195 -+006116 001604 ZZ2195=ZZ2195+ZZ2195 -+006116 003410 ZZ2195=ZZ2195+ZZ2195 -+006116 007020 ZZ2195=ZZ2195+ZZ2195 -+006116 016040 ZZ2195=ZZ2195+ZZ2195 -+006116 034100 ZZ2195=ZZ2195+ZZ2195 -+006116 070200 ZZ2195=ZZ2195+ZZ2195 -+006116 160400 ZZ2195=ZZ2195+ZZ2195 -+006116 014255 0 8192 -ZZ1195 -+006117 160400 0 ZZ2195 -- mark 1880, -136 /44 orio -+006120 777356 ZZ2196=ZZ2196+ZZ2196 -+006120 776734 ZZ2196=ZZ2196+ZZ2196 -+006120 775670 ZZ2196=ZZ2196+ZZ2196 -+006120 773560 ZZ2196=ZZ2196+ZZ2196 -+006120 767340 ZZ2196=ZZ2196+ZZ2196 -+006120 756700 ZZ2196=ZZ2196+ZZ2196 -+006120 735600 ZZ2196=ZZ2196+ZZ2196 -+006120 673400 ZZ2196=ZZ2196+ZZ2196 -+006120 014250 0 8192 -ZZ1196 -+006121 673400 0 ZZ2196 -- mark 1887, 480 /123 taur -+006122 001700 ZZ2197=ZZ2197+ZZ2197 -+006122 003600 ZZ2197=ZZ2197+ZZ2197 -+006122 007400 ZZ2197=ZZ2197+ZZ2197 -+006122 017000 ZZ2197=ZZ2197+ZZ2197 -+006122 036000 ZZ2197=ZZ2197+ZZ2197 -+006122 074000 ZZ2197=ZZ2197+ZZ2197 -+006122 170000 ZZ2197=ZZ2197+ZZ2197 -+006122 360000 ZZ2197=ZZ2197+ZZ2197 -+006122 014241 0 8192 -ZZ1197 -+006123 360000 0 ZZ2197 -- mark 1948, -338 /14 leps -+006124 776532 ZZ2198=ZZ2198+ZZ2198 -+006124 775264 ZZ2198=ZZ2198+ZZ2198 -+006124 772550 ZZ2198=ZZ2198+ZZ2198 -+006124 765320 ZZ2198=ZZ2198+ZZ2198 -+006124 752640 ZZ2198=ZZ2198+ZZ2198 -+006124 725500 ZZ2198=ZZ2198+ZZ2198 -+006124 653200 ZZ2198=ZZ2198+ZZ2198 -+006124 526400 ZZ2198=ZZ2198+ZZ2198 -+006124 014144 0 8192 -ZZ1198 -+006125 526400 0 ZZ2198 -- mark 2274, 296 /31 gemi -+006126 001120 ZZ2199=ZZ2199+ZZ2199 -+006126 002240 ZZ2199=ZZ2199+ZZ2199 -+006126 004500 ZZ2199=ZZ2199+ZZ2199 -+006126 011200 ZZ2199=ZZ2199+ZZ2199 -+006126 022400 ZZ2199=ZZ2199+ZZ2199 -+006126 045000 ZZ2199=ZZ2199+ZZ2199 -+006126 112000 ZZ2199=ZZ2199+ZZ2199 -+006126 224000 ZZ2199=ZZ2199+ZZ2199 -+006126 013436 0 8192 -ZZ1199 -+006127 224000 0 ZZ2199 -- mark 2460, 380 /54 gemi -+006130 001370 ZZ2200=ZZ2200+ZZ2200 -+006130 002760 ZZ2200=ZZ2200+ZZ2200 -+006130 005740 ZZ2200=ZZ2200+ZZ2200 -+006130 013700 ZZ2200=ZZ2200+ZZ2200 -+006130 027600 ZZ2200=ZZ2200+ZZ2200 -+006130 057400 ZZ2200=ZZ2200+ZZ2200 -+006130 137000 ZZ2200=ZZ2200+ZZ2200 -+006130 276000 ZZ2200=ZZ2200+ZZ2200 -+006130 013144 0 8192 -ZZ1200 -+006131 276000 0 ZZ2200 -- mark 2470, 504 /55 gemi -+006132 001760 ZZ2201=ZZ2201+ZZ2201 -+006132 003740 ZZ2201=ZZ2201+ZZ2201 -+006132 007700 ZZ2201=ZZ2201+ZZ2201 -+006132 017600 ZZ2201=ZZ2201+ZZ2201 -+006132 037400 ZZ2201=ZZ2201+ZZ2201 -+006132 077000 ZZ2201=ZZ2201+ZZ2201 -+006132 176000 ZZ2201=ZZ2201+ZZ2201 -+006132 374000 ZZ2201=ZZ2201+ZZ2201 -+006132 013132 0 8192 -ZZ1201 -+006133 374000 0 ZZ2201 -- mark 2513, 193 / 3 cmin -+006134 000602 ZZ2202=ZZ2202+ZZ2202 -+006134 001404 ZZ2202=ZZ2202+ZZ2202 -+006134 003010 ZZ2202=ZZ2202+ZZ2202 -+006134 006020 ZZ2202=ZZ2202+ZZ2202 -+006134 014040 ZZ2202=ZZ2202+ZZ2202 -+006134 030100 ZZ2202=ZZ2202+ZZ2202 -+006134 060200 ZZ2202=ZZ2202+ZZ2202 -+006134 140400 ZZ2202=ZZ2202+ZZ2202 -+006134 013057 0 8192 -ZZ1202 -+006135 140400 0 ZZ2202 -- mark 2967, 154 /11 hyda -+006136 000464 ZZ2203=ZZ2203+ZZ2203 -+006136 001150 ZZ2203=ZZ2203+ZZ2203 -+006136 002320 ZZ2203=ZZ2203+ZZ2203 -+006136 004640 ZZ2203=ZZ2203+ZZ2203 -+006136 011500 ZZ2203=ZZ2203+ZZ2203 -+006136 023200 ZZ2203=ZZ2203+ZZ2203 -+006136 046400 ZZ2203=ZZ2203+ZZ2203 -+006136 115000 ZZ2203=ZZ2203+ZZ2203 -+006136 012151 0 8192 -ZZ1203 -+006137 115000 0 ZZ2203 -- mark 3016, 144 /16 hyda -+006140 000440 ZZ2204=ZZ2204+ZZ2204 -+006140 001100 ZZ2204=ZZ2204+ZZ2204 -+006140 002200 ZZ2204=ZZ2204+ZZ2204 -+006140 004400 ZZ2204=ZZ2204+ZZ2204 -+006140 011000 ZZ2204=ZZ2204+ZZ2204 -+006140 022000 ZZ2204=ZZ2204+ZZ2204 -+006140 044000 ZZ2204=ZZ2204+ZZ2204 -+006140 110000 ZZ2204=ZZ2204+ZZ2204 -+006140 012070 0 8192 -ZZ1204 -+006141 110000 0 ZZ2204 -- mark 3424, 393 /30 leon -+006142 001422 ZZ2205=ZZ2205+ZZ2205 -+006142 003044 ZZ2205=ZZ2205+ZZ2205 -+006142 006110 ZZ2205=ZZ2205+ZZ2205 -+006142 014220 ZZ2205=ZZ2205+ZZ2205 -+006142 030440 ZZ2205=ZZ2205+ZZ2205 -+006142 061100 ZZ2205=ZZ2205+ZZ2205 -+006142 142200 ZZ2205=ZZ2205+ZZ2205 -+006142 304400 ZZ2205=ZZ2205+ZZ2205 -+006142 011240 0 8192 -ZZ1205 -+006143 304400 0 ZZ2205 -- mark 3496, 463 /41 leon, algieba -+006144 001636 ZZ2206=ZZ2206+ZZ2206 -+006144 003474 ZZ2206=ZZ2206+ZZ2206 -+006144 007170 ZZ2206=ZZ2206+ZZ2206 -+006144 016360 ZZ2206=ZZ2206+ZZ2206 -+006144 034740 ZZ2206=ZZ2206+ZZ2206 -+006144 071700 ZZ2206=ZZ2206+ZZ2206 -+006144 163600 ZZ2206=ZZ2206+ZZ2206 -+006144 347400 ZZ2206=ZZ2206+ZZ2206 -+006144 011130 0 8192 -ZZ1206 -+006145 347400 0 ZZ2206 -- mark 3668, -357 /nu hyda -+006146 776464 ZZ2207=ZZ2207+ZZ2207 -+006146 775150 ZZ2207=ZZ2207+ZZ2207 -+006146 772320 ZZ2207=ZZ2207+ZZ2207 -+006146 764640 ZZ2207=ZZ2207+ZZ2207 -+006146 751500 ZZ2207=ZZ2207+ZZ2207 -+006146 723200 ZZ2207=ZZ2207+ZZ2207 -+006146 646400 ZZ2207=ZZ2207+ZZ2207 -+006146 515000 ZZ2207=ZZ2207+ZZ2207 -+006146 010654 0 8192 -ZZ1207 -+006147 515000 0 ZZ2207 -- mark 3805, 479 /68 leon -+006150 001676 ZZ2208=ZZ2208+ZZ2208 -+006150 003574 ZZ2208=ZZ2208+ZZ2208 -+006150 007370 ZZ2208=ZZ2208+ZZ2208 -+006150 016760 ZZ2208=ZZ2208+ZZ2208 -+006150 035740 ZZ2208=ZZ2208+ZZ2208 -+006150 073700 ZZ2208=ZZ2208+ZZ2208 -+006150 167600 ZZ2208=ZZ2208+ZZ2208 -+006150 357400 ZZ2208=ZZ2208+ZZ2208 -+006150 010443 0 8192 -ZZ1208 -+006151 357400 0 ZZ2208 -- mark 3806, 364 /10 leon -+006152 001330 ZZ2209=ZZ2209+ZZ2209 -+006152 002660 ZZ2209=ZZ2209+ZZ2209 -+006152 005540 ZZ2209=ZZ2209+ZZ2209 -+006152 013300 ZZ2209=ZZ2209+ZZ2209 -+006152 026600 ZZ2209=ZZ2209+ZZ2209 -+006152 055400 ZZ2209=ZZ2209+ZZ2209 -+006152 133000 ZZ2209=ZZ2209+ZZ2209 -+006152 266000 ZZ2209=ZZ2209+ZZ2209 -+006152 010442 0 8192 -ZZ1209 -+006153 266000 0 ZZ2209 -- mark 4124, -502 / 2 corv -+006154 776022 ZZ2210=ZZ2210+ZZ2210 -+006154 774044 ZZ2210=ZZ2210+ZZ2210 -+006154 770110 ZZ2210=ZZ2210+ZZ2210 -+006154 760220 ZZ2210=ZZ2210+ZZ2210 -+006154 740440 ZZ2210=ZZ2210+ZZ2210 -+006154 701100 ZZ2210=ZZ2210+ZZ2210 -+006154 602200 ZZ2210=ZZ2210+ZZ2210 -+006154 404400 ZZ2210=ZZ2210+ZZ2210 -+006154 007744 0 8192 -ZZ1210 -+006155 404400 0 ZZ2210 -- mark 4157, -387 / 4 corv -+006156 776370 ZZ2211=ZZ2211+ZZ2211 -+006156 774760 ZZ2211=ZZ2211+ZZ2211 -+006156 771740 ZZ2211=ZZ2211+ZZ2211 -+006156 763700 ZZ2211=ZZ2211+ZZ2211 -+006156 747600 ZZ2211=ZZ2211+ZZ2211 -+006156 717400 ZZ2211=ZZ2211+ZZ2211 -+006156 637000 ZZ2211=ZZ2211+ZZ2211 -+006156 476000 ZZ2211=ZZ2211+ZZ2211 -+006156 007703 0 8192 -ZZ1211 -+006157 476000 0 ZZ2211 -- mark 4236, -363 / 7 corv -+006160 776450 ZZ2212=ZZ2212+ZZ2212 -+006160 775120 ZZ2212=ZZ2212+ZZ2212 -+006160 772240 ZZ2212=ZZ2212+ZZ2212 -+006160 764500 ZZ2212=ZZ2212+ZZ2212 -+006160 751200 ZZ2212=ZZ2212+ZZ2212 -+006160 722400 ZZ2212=ZZ2212+ZZ2212 -+006160 645000 ZZ2212=ZZ2212+ZZ2212 -+006160 512000 ZZ2212=ZZ2212+ZZ2212 -+006160 007564 0 8192 -ZZ1212 -+006161 512000 0 ZZ2212 -- mark 4304, -21 /29 virg -+006162 777724 ZZ2213=ZZ2213+ZZ2213 -+006162 777650 ZZ2213=ZZ2213+ZZ2213 -+006162 777520 ZZ2213=ZZ2213+ZZ2213 -+006162 777240 ZZ2213=ZZ2213+ZZ2213 -+006162 776500 ZZ2213=ZZ2213+ZZ2213 -+006162 775200 ZZ2213=ZZ2213+ZZ2213 -+006162 772400 ZZ2213=ZZ2213+ZZ2213 -+006162 765000 ZZ2213=ZZ2213+ZZ2213 -+006162 007460 0 8192 -ZZ1213 -+006163 765000 0 ZZ2213 -- mark 4384, 90 /43 virg -+006164 000264 ZZ2214=ZZ2214+ZZ2214 -+006164 000550 ZZ2214=ZZ2214+ZZ2214 -+006164 001320 ZZ2214=ZZ2214+ZZ2214 -+006164 002640 ZZ2214=ZZ2214+ZZ2214 -+006164 005500 ZZ2214=ZZ2214+ZZ2214 -+006164 013200 ZZ2214=ZZ2214+ZZ2214 -+006164 026400 ZZ2214=ZZ2214+ZZ2214 -+006164 055000 ZZ2214=ZZ2214+ZZ2214 -+006164 007340 0 8192 -ZZ1214 -+006165 055000 0 ZZ2214 -- mark 4421, 262 /47 virg -+006166 001014 ZZ2215=ZZ2215+ZZ2215 -+006166 002030 ZZ2215=ZZ2215+ZZ2215 -+006166 004060 ZZ2215=ZZ2215+ZZ2215 -+006166 010140 ZZ2215=ZZ2215+ZZ2215 -+006166 020300 ZZ2215=ZZ2215+ZZ2215 -+006166 040600 ZZ2215=ZZ2215+ZZ2215 -+006166 101400 ZZ2215=ZZ2215+ZZ2215 -+006166 203000 ZZ2215=ZZ2215+ZZ2215 -+006166 007273 0 8192 -ZZ1215 -+006167 203000 0 ZZ2215 -- mark 4606, -2 /79 virg -+006170 777772 ZZ2216=ZZ2216+ZZ2216 -+006170 777764 ZZ2216=ZZ2216+ZZ2216 -+006170 777750 ZZ2216=ZZ2216+ZZ2216 -+006170 777720 ZZ2216=ZZ2216+ZZ2216 -+006170 777640 ZZ2216=ZZ2216+ZZ2216 -+006170 777500 ZZ2216=ZZ2216+ZZ2216 -+006170 777200 ZZ2216=ZZ2216+ZZ2216 -+006170 776400 ZZ2216=ZZ2216+ZZ2216 -+006170 007002 0 8192 -ZZ1216 -+006171 776400 0 ZZ2216 -- mark 4721, 430 / 8 boot -+006172 001534 ZZ2217=ZZ2217+ZZ2217 -+006172 003270 ZZ2217=ZZ2217+ZZ2217 -+006172 006560 ZZ2217=ZZ2217+ZZ2217 -+006172 015340 ZZ2217=ZZ2217+ZZ2217 -+006172 032700 ZZ2217=ZZ2217+ZZ2217 -+006172 065600 ZZ2217=ZZ2217+ZZ2217 -+006172 153400 ZZ2217=ZZ2217+ZZ2217 -+006172 327000 ZZ2217=ZZ2217+ZZ2217 -+006172 006617 0 8192 -ZZ1217 -+006173 327000 0 ZZ2217 -- mark 5037, -356 / 9 libr -+006174 776466 ZZ2218=ZZ2218+ZZ2218 -+006174 775154 ZZ2218=ZZ2218+ZZ2218 -+006174 772330 ZZ2218=ZZ2218+ZZ2218 -+006174 764660 ZZ2218=ZZ2218+ZZ2218 -+006174 751540 ZZ2218=ZZ2218+ZZ2218 -+006174 723300 ZZ2218=ZZ2218+ZZ2218 -+006174 646600 ZZ2218=ZZ2218+ZZ2218 -+006174 515400 ZZ2218=ZZ2218+ZZ2218 -+006174 006123 0 8192 -ZZ1218 -+006175 515400 0 ZZ2218 -- mark 5186, -205 /27 libr -+006176 777144 ZZ2219=ZZ2219+ZZ2219 -+006176 776310 ZZ2219=ZZ2219+ZZ2219 -+006176 774620 ZZ2219=ZZ2219+ZZ2219 -+006176 771440 ZZ2219=ZZ2219+ZZ2219 -+006176 763100 ZZ2219=ZZ2219+ZZ2219 -+006176 746200 ZZ2219=ZZ2219+ZZ2219 -+006176 714400 ZZ2219=ZZ2219+ZZ2219 -+006176 631000 ZZ2219=ZZ2219+ZZ2219 -+006176 005676 0 8192 -ZZ1219 -+006177 631000 0 ZZ2219 -- mark 5344, 153 /24 serp -+006200 000462 ZZ2220=ZZ2220+ZZ2220 -+006200 001144 ZZ2220=ZZ2220+ZZ2220 -+006200 002310 ZZ2220=ZZ2220+ZZ2220 -+006200 004620 ZZ2220=ZZ2220+ZZ2220 -+006200 011440 ZZ2220=ZZ2220+ZZ2220 -+006200 023100 ZZ2220=ZZ2220+ZZ2220 -+006200 046200 ZZ2220=ZZ2220+ZZ2220 -+006200 114400 ZZ2220=ZZ2220+ZZ2220 -+006200 005440 0 8192 -ZZ1220 -+006201 114400 0 ZZ2220 -- mark 5357, 358 /28 serp -+006202 001314 ZZ2221=ZZ2221+ZZ2221 -+006202 002630 ZZ2221=ZZ2221+ZZ2221 -+006202 005460 ZZ2221=ZZ2221+ZZ2221 -+006202 013140 ZZ2221=ZZ2221+ZZ2221 -+006202 026300 ZZ2221=ZZ2221+ZZ2221 -+006202 054600 ZZ2221=ZZ2221+ZZ2221 -+006202 131400 ZZ2221=ZZ2221+ZZ2221 -+006202 263000 ZZ2221=ZZ2221+ZZ2221 -+006202 005423 0 8192 -ZZ1221 -+006203 263000 0 ZZ2221 -- mark 5373, -71 /32 serp -+006204 777560 ZZ2222=ZZ2222+ZZ2222 -+006204 777340 ZZ2222=ZZ2222+ZZ2222 -+006204 776700 ZZ2222=ZZ2222+ZZ2222 -+006204 775600 ZZ2222=ZZ2222+ZZ2222 -+006204 773400 ZZ2222=ZZ2222+ZZ2222 -+006204 767000 ZZ2222=ZZ2222+ZZ2222 -+006204 756000 ZZ2222=ZZ2222+ZZ2222 -+006204 734000 ZZ2222=ZZ2222+ZZ2222 -+006204 005403 0 8192 -ZZ1222 -+006205 734000 0 ZZ2222 -- mark 5430, -508 / 7 scor -+006206 776006 ZZ2223=ZZ2223+ZZ2223 -+006206 774014 ZZ2223=ZZ2223+ZZ2223 -+006206 770030 ZZ2223=ZZ2223+ZZ2223 -+006206 760060 ZZ2223=ZZ2223+ZZ2223 -+006206 740140 ZZ2223=ZZ2223+ZZ2223 -+006206 700300 ZZ2223=ZZ2223+ZZ2223 -+006206 600600 ZZ2223=ZZ2223+ZZ2223 -+006206 401400 ZZ2223=ZZ2223+ZZ2223 -+006206 005312 0 8192 -ZZ1223 -+006207 401400 0 ZZ2223 -- mark 5459, -445 / 8 scor -+006210 776204 ZZ2224=ZZ2224+ZZ2224 -+006210 774410 ZZ2224=ZZ2224+ZZ2224 -+006210 771020 ZZ2224=ZZ2224+ZZ2224 -+006210 762040 ZZ2224=ZZ2224+ZZ2224 -+006210 744100 ZZ2224=ZZ2224+ZZ2224 -+006210 710200 ZZ2224=ZZ2224+ZZ2224 -+006210 620400 ZZ2224=ZZ2224+ZZ2224 -+006210 441000 ZZ2224=ZZ2224+ZZ2224 -+006210 005255 0 8192 -ZZ1224 -+006211 441000 0 ZZ2224 -- mark 5513, -78 / 1 ophi -+006212 777542 ZZ2225=ZZ2225+ZZ2225 -+006212 777304 ZZ2225=ZZ2225+ZZ2225 -+006212 776610 ZZ2225=ZZ2225+ZZ2225 -+006212 775420 ZZ2225=ZZ2225+ZZ2225 -+006212 773040 ZZ2225=ZZ2225+ZZ2225 -+006212 766100 ZZ2225=ZZ2225+ZZ2225 -+006212 754200 ZZ2225=ZZ2225+ZZ2225 -+006212 730400 ZZ2225=ZZ2225+ZZ2225 -+006212 005167 0 8192 -ZZ1225 -+006213 730400 0 ZZ2225 -- mark 5536, -101 / 2 ophi -+006214 777464 ZZ2226=ZZ2226+ZZ2226 -+006214 777150 ZZ2226=ZZ2226+ZZ2226 -+006214 776320 ZZ2226=ZZ2226+ZZ2226 -+006214 774640 ZZ2226=ZZ2226+ZZ2226 -+006214 771500 ZZ2226=ZZ2226+ZZ2226 -+006214 763200 ZZ2226=ZZ2226+ZZ2226 -+006214 746400 ZZ2226=ZZ2226+ZZ2226 -+006214 715000 ZZ2226=ZZ2226+ZZ2226 -+006214 005140 0 8192 -ZZ1226 -+006215 715000 0 ZZ2226 -- mark 5609, 494 /27 herc -+006216 001734 ZZ2227=ZZ2227+ZZ2227 -+006216 003670 ZZ2227=ZZ2227+ZZ2227 -+006216 007560 ZZ2227=ZZ2227+ZZ2227 -+006216 017340 ZZ2227=ZZ2227+ZZ2227 -+006216 036700 ZZ2227=ZZ2227+ZZ2227 -+006216 075600 ZZ2227=ZZ2227+ZZ2227 -+006216 173400 ZZ2227=ZZ2227+ZZ2227 -+006216 367000 ZZ2227=ZZ2227+ZZ2227 -+006216 005027 0 8192 -ZZ1227 -+006217 367000 0 ZZ2227 -- mark 5641, -236 /13 ophi -+006220 777046 ZZ2228=ZZ2228+ZZ2228 -+006220 776114 ZZ2228=ZZ2228+ZZ2228 -+006220 774230 ZZ2228=ZZ2228+ZZ2228 -+006220 770460 ZZ2228=ZZ2228+ZZ2228 -+006220 761140 ZZ2228=ZZ2228+ZZ2228 -+006220 742300 ZZ2228=ZZ2228+ZZ2228 -+006220 704600 ZZ2228=ZZ2228+ZZ2228 -+006220 611400 ZZ2228=ZZ2228+ZZ2228 -+006220 004767 0 8192 -ZZ1228 -+006221 611400 0 ZZ2228 -- mark 5828, -355 /35 ophi -+006222 776470 ZZ2229=ZZ2229+ZZ2229 -+006222 775160 ZZ2229=ZZ2229+ZZ2229 -+006222 772340 ZZ2229=ZZ2229+ZZ2229 -+006222 764700 ZZ2229=ZZ2229+ZZ2229 -+006222 751600 ZZ2229=ZZ2229+ZZ2229 -+006222 723400 ZZ2229=ZZ2229+ZZ2229 -+006222 647000 ZZ2229=ZZ2229+ZZ2229 -+006222 516000 ZZ2229=ZZ2229+ZZ2229 -+006222 004474 0 8192 -ZZ1229 -+006223 516000 0 ZZ2229 -- mark 5860, 330 /64 herc -+006224 001224 ZZ2230=ZZ2230+ZZ2230 -+006224 002450 ZZ2230=ZZ2230+ZZ2230 -+006224 005120 ZZ2230=ZZ2230+ZZ2230 -+006224 012240 ZZ2230=ZZ2230+ZZ2230 -+006224 024500 ZZ2230=ZZ2230+ZZ2230 -+006224 051200 ZZ2230=ZZ2230+ZZ2230 -+006224 122400 ZZ2230=ZZ2230+ZZ2230 -+006224 245000 ZZ2230=ZZ2230+ZZ2230 -+006224 004434 0 8192 -ZZ1230 -+006225 245000 0 ZZ2230 -- mark 5984, -349 /55 serp -+006226 776504 ZZ2231=ZZ2231+ZZ2231 -+006226 775210 ZZ2231=ZZ2231+ZZ2231 -+006226 772420 ZZ2231=ZZ2231+ZZ2231 -+006226 765040 ZZ2231=ZZ2231+ZZ2231 -+006226 752100 ZZ2231=ZZ2231+ZZ2231 -+006226 724200 ZZ2231=ZZ2231+ZZ2231 -+006226 650400 ZZ2231=ZZ2231+ZZ2231 -+006226 521000 ZZ2231=ZZ2231+ZZ2231 -+006226 004240 0 8192 -ZZ1231 -+006227 521000 0 ZZ2231 -- mark 6047, 63 /62 ophi -+006230 000176 ZZ2232=ZZ2232+ZZ2232 -+006230 000374 ZZ2232=ZZ2232+ZZ2232 -+006230 000770 ZZ2232=ZZ2232+ZZ2232 -+006230 001760 ZZ2232=ZZ2232+ZZ2232 -+006230 003740 ZZ2232=ZZ2232+ZZ2232 -+006230 007700 ZZ2232=ZZ2232+ZZ2232 -+006230 017600 ZZ2232=ZZ2232+ZZ2232 -+006230 037400 ZZ2232=ZZ2232+ZZ2232 -+006230 004141 0 8192 -ZZ1232 -+006231 037400 0 ZZ2232 -- mark 6107, -222 /64 ophi -+006232 777102 ZZ2233=ZZ2233+ZZ2233 -+006232 776204 ZZ2233=ZZ2233+ZZ2233 -+006232 774410 ZZ2233=ZZ2233+ZZ2233 -+006232 771020 ZZ2233=ZZ2233+ZZ2233 -+006232 762040 ZZ2233=ZZ2233+ZZ2233 -+006232 744100 ZZ2233=ZZ2233+ZZ2233 -+006232 710200 ZZ2233=ZZ2233+ZZ2233 -+006232 620400 ZZ2233=ZZ2233+ZZ2233 -+006232 004045 0 8192 -ZZ1233 -+006233 620400 0 ZZ2233 -- mark 6159, 217 /72 ophi -+006234 000662 ZZ2234=ZZ2234+ZZ2234 -+006234 001544 ZZ2234=ZZ2234+ZZ2234 -+006234 003310 ZZ2234=ZZ2234+ZZ2234 -+006234 006620 ZZ2234=ZZ2234+ZZ2234 -+006234 015440 ZZ2234=ZZ2234+ZZ2234 -+006234 033100 ZZ2234=ZZ2234+ZZ2234 -+006234 066200 ZZ2234=ZZ2234+ZZ2234 -+006234 154400 ZZ2234=ZZ2234+ZZ2234 -+006234 003761 0 8192 -ZZ1234 -+006235 154400 0 ZZ2234 -- mark 6236, -66 /58 serp -+006236 777572 ZZ2235=ZZ2235+ZZ2235 -+006236 777364 ZZ2235=ZZ2235+ZZ2235 -+006236 776750 ZZ2235=ZZ2235+ZZ2235 -+006236 775720 ZZ2235=ZZ2235+ZZ2235 -+006236 773640 ZZ2235=ZZ2235+ZZ2235 -+006236 767500 ZZ2235=ZZ2235+ZZ2235 -+006236 757200 ZZ2235=ZZ2235+ZZ2235 -+006236 736400 ZZ2235=ZZ2235+ZZ2235 -+006236 003644 0 8192 -ZZ1235 -+006237 736400 0 ZZ2235 -- mark 6439, -483 /37 sgtr -+006240 776070 ZZ2236=ZZ2236+ZZ2236 -+006240 774160 ZZ2236=ZZ2236+ZZ2236 -+006240 770340 ZZ2236=ZZ2236+ZZ2236 -+006240 760700 ZZ2236=ZZ2236+ZZ2236 -+006240 741600 ZZ2236=ZZ2236+ZZ2236 -+006240 703400 ZZ2236=ZZ2236+ZZ2236 -+006240 607000 ZZ2236=ZZ2236+ZZ2236 -+006240 416000 ZZ2236=ZZ2236+ZZ2236 -+006240 003331 0 8192 -ZZ1236 -+006241 416000 0 ZZ2236 -- mark 6490, 312 /17 aqil -+006242 001160 ZZ2237=ZZ2237+ZZ2237 -+006242 002340 ZZ2237=ZZ2237+ZZ2237 -+006242 004700 ZZ2237=ZZ2237+ZZ2237 -+006242 011600 ZZ2237=ZZ2237+ZZ2237 -+006242 023400 ZZ2237=ZZ2237+ZZ2237 -+006242 047000 ZZ2237=ZZ2237+ZZ2237 -+006242 116000 ZZ2237=ZZ2237+ZZ2237 -+006242 234000 ZZ2237=ZZ2237+ZZ2237 -+006242 003246 0 8192 -ZZ1237 -+006243 234000 0 ZZ2237 -- mark 6491, -115 /16 aqil -+006244 777430 ZZ2238=ZZ2238+ZZ2238 -+006244 777060 ZZ2238=ZZ2238+ZZ2238 -+006244 776140 ZZ2238=ZZ2238+ZZ2238 -+006244 774300 ZZ2238=ZZ2238+ZZ2238 -+006244 770600 ZZ2238=ZZ2238+ZZ2238 -+006244 761400 ZZ2238=ZZ2238+ZZ2238 -+006244 743000 ZZ2238=ZZ2238+ZZ2238 -+006244 706000 ZZ2238=ZZ2238+ZZ2238 -+006244 003245 0 8192 -ZZ1238 -+006245 706000 0 ZZ2238 -- mark 6507, -482 /41 sgtr -+006246 776072 ZZ2239=ZZ2239+ZZ2239 -+006246 774164 ZZ2239=ZZ2239+ZZ2239 -+006246 770350 ZZ2239=ZZ2239+ZZ2239 -+006246 760720 ZZ2239=ZZ2239+ZZ2239 -+006246 741640 ZZ2239=ZZ2239+ZZ2239 -+006246 703500 ZZ2239=ZZ2239+ZZ2239 -+006246 607200 ZZ2239=ZZ2239+ZZ2239 -+006246 416400 ZZ2239=ZZ2239+ZZ2239 -+006246 003225 0 8192 -ZZ1239 -+006247 416400 0 ZZ2239 -- mark 6602, 66 /30 aqil -+006250 000204 ZZ2240=ZZ2240+ZZ2240 -+006250 000410 ZZ2240=ZZ2240+ZZ2240 -+006250 001020 ZZ2240=ZZ2240+ZZ2240 -+006250 002040 ZZ2240=ZZ2240+ZZ2240 -+006250 004100 ZZ2240=ZZ2240+ZZ2240 -+006250 010200 ZZ2240=ZZ2240+ZZ2240 -+006250 020400 ZZ2240=ZZ2240+ZZ2240 -+006250 041000 ZZ2240=ZZ2240+ZZ2240 -+006250 003066 0 8192 -ZZ1240 -+006251 041000 0 ZZ2240 -- mark 6721, 236 /50 aqil -+006252 000730 ZZ2241=ZZ2241+ZZ2241 -+006252 001660 ZZ2241=ZZ2241+ZZ2241 -+006252 003540 ZZ2241=ZZ2241+ZZ2241 -+006252 007300 ZZ2241=ZZ2241+ZZ2241 -+006252 016600 ZZ2241=ZZ2241+ZZ2241 -+006252 035400 ZZ2241=ZZ2241+ZZ2241 -+006252 073000 ZZ2241=ZZ2241+ZZ2241 -+006252 166000 ZZ2241=ZZ2241+ZZ2241 -+006252 002677 0 8192 -ZZ1241 -+006253 166000 0 ZZ2241 -- mark 6794, 437 /12 sgte -+006254 001552 ZZ2242=ZZ2242+ZZ2242 -+006254 003324 ZZ2242=ZZ2242+ZZ2242 -+006254 006650 ZZ2242=ZZ2242+ZZ2242 -+006254 015520 ZZ2242=ZZ2242+ZZ2242 -+006254 033240 ZZ2242=ZZ2242+ZZ2242 -+006254 066500 ZZ2242=ZZ2242+ZZ2242 -+006254 155200 ZZ2242=ZZ2242+ZZ2242 -+006254 332400 ZZ2242=ZZ2242+ZZ2242 -+006254 002566 0 8192 -ZZ1242 -+006255 332400 0 ZZ2242 -- mark 6862, -25 /65 aqil -+006256 777714 ZZ2243=ZZ2243+ZZ2243 -+006256 777630 ZZ2243=ZZ2243+ZZ2243 -+006256 777460 ZZ2243=ZZ2243+ZZ2243 -+006256 777140 ZZ2243=ZZ2243+ZZ2243 -+006256 776300 ZZ2243=ZZ2243+ZZ2243 -+006256 774600 ZZ2243=ZZ2243+ZZ2243 -+006256 771400 ZZ2243=ZZ2243+ZZ2243 -+006256 763000 ZZ2243=ZZ2243+ZZ2243 -+006256 002462 0 8192 -ZZ1243 -+006257 763000 0 ZZ2243 -- mark 6914, -344 / 9 capr -+006260 776516 ZZ2244=ZZ2244+ZZ2244 -+006260 775234 ZZ2244=ZZ2244+ZZ2244 -+006260 772470 ZZ2244=ZZ2244+ZZ2244 -+006260 765160 ZZ2244=ZZ2244+ZZ2244 -+006260 752340 ZZ2244=ZZ2244+ZZ2244 -+006260 724700 ZZ2244=ZZ2244+ZZ2244 -+006260 651600 ZZ2244=ZZ2244+ZZ2244 -+006260 523400 ZZ2244=ZZ2244+ZZ2244 -+006260 002376 0 8192 -ZZ1244 -+006261 523400 0 ZZ2244 -- mark 7014, 324 / 6 dlph -+006262 001210 ZZ2245=ZZ2245+ZZ2245 -+006262 002420 ZZ2245=ZZ2245+ZZ2245 -+006262 005040 ZZ2245=ZZ2245+ZZ2245 -+006262 012100 ZZ2245=ZZ2245+ZZ2245 -+006262 024200 ZZ2245=ZZ2245+ZZ2245 -+006262 050400 ZZ2245=ZZ2245+ZZ2245 -+006262 121000 ZZ2245=ZZ2245+ZZ2245 -+006262 242000 ZZ2245=ZZ2245+ZZ2245 -+006262 002232 0 8192 -ZZ1245 -+006263 242000 0 ZZ2245 -- mark 7318, -137 /22 aqar -+006264 777354 ZZ2246=ZZ2246+ZZ2246 -+006264 776730 ZZ2246=ZZ2246+ZZ2246 -+006264 775660 ZZ2246=ZZ2246+ZZ2246 -+006264 773540 ZZ2246=ZZ2246+ZZ2246 -+006264 767300 ZZ2246=ZZ2246+ZZ2246 -+006264 756600 ZZ2246=ZZ2246+ZZ2246 -+006264 735400 ZZ2246=ZZ2246+ZZ2246 -+006264 673000 ZZ2246=ZZ2246+ZZ2246 -+006264 001552 0 8192 -ZZ1246 -+006265 673000 0 ZZ2246 -- mark 7391, 214 / 8 pegs -+006266 000654 ZZ2247=ZZ2247+ZZ2247 -+006266 001530 ZZ2247=ZZ2247+ZZ2247 -+006266 003260 ZZ2247=ZZ2247+ZZ2247 -+006266 006540 ZZ2247=ZZ2247+ZZ2247 -+006266 015300 ZZ2247=ZZ2247+ZZ2247 -+006266 032600 ZZ2247=ZZ2247+ZZ2247 -+006266 065400 ZZ2247=ZZ2247+ZZ2247 -+006266 153000 ZZ2247=ZZ2247+ZZ2247 -+006266 001441 0 8192 -ZZ1247 -+006267 153000 0 ZZ2247 -- mark 7404, -377 /49 capr -+006270 776414 ZZ2248=ZZ2248+ZZ2248 -+006270 775030 ZZ2248=ZZ2248+ZZ2248 -+006270 772060 ZZ2248=ZZ2248+ZZ2248 -+006270 764140 ZZ2248=ZZ2248+ZZ2248 -+006270 750300 ZZ2248=ZZ2248+ZZ2248 -+006270 720600 ZZ2248=ZZ2248+ZZ2248 -+006270 641400 ZZ2248=ZZ2248+ZZ2248 -+006270 503000 ZZ2248=ZZ2248+ZZ2248 -+006270 001424 0 8192 -ZZ1248 -+006271 503000 0 ZZ2248 -- mark 7513, -18 /34 aqar -+006272 777732 ZZ2249=ZZ2249+ZZ2249 -+006272 777664 ZZ2249=ZZ2249+ZZ2249 -+006272 777550 ZZ2249=ZZ2249+ZZ2249 -+006272 777320 ZZ2249=ZZ2249+ZZ2249 -+006272 776640 ZZ2249=ZZ2249+ZZ2249 -+006272 775500 ZZ2249=ZZ2249+ZZ2249 -+006272 773200 ZZ2249=ZZ2249+ZZ2249 -+006272 766400 ZZ2249=ZZ2249+ZZ2249 -+006272 001247 0 8192 -ZZ1249 -+006273 766400 0 ZZ2249 -- mark 7539, 130 /26 pegs -+006274 000404 ZZ2250=ZZ2250+ZZ2250 -+006274 001010 ZZ2250=ZZ2250+ZZ2250 -+006274 002020 ZZ2250=ZZ2250+ZZ2250 -+006274 004040 ZZ2250=ZZ2250+ZZ2250 -+006274 010100 ZZ2250=ZZ2250+ZZ2250 -+006274 020200 ZZ2250=ZZ2250+ZZ2250 -+006274 040400 ZZ2250=ZZ2250+ZZ2250 -+006274 101000 ZZ2250=ZZ2250+ZZ2250 -+006274 001215 0 8192 -ZZ1250 -+006275 101000 0 ZZ2250 -- mark 7644, -12 /55 aqar -+006276 777746 ZZ2251=ZZ2251+ZZ2251 -+006276 777714 ZZ2251=ZZ2251+ZZ2251 -+006276 777630 ZZ2251=ZZ2251+ZZ2251 -+006276 777460 ZZ2251=ZZ2251+ZZ2251 -+006276 777140 ZZ2251=ZZ2251+ZZ2251 -+006276 776300 ZZ2251=ZZ2251+ZZ2251 -+006276 774600 ZZ2251=ZZ2251+ZZ2251 -+006276 771400 ZZ2251=ZZ2251+ZZ2251 -+006276 001044 0 8192 -ZZ1251 -+006277 771400 0 ZZ2251 -- mark 7717, 235 /42 pegs -+006300 000726 ZZ2252=ZZ2252+ZZ2252 -+006300 001654 ZZ2252=ZZ2252+ZZ2252 -+006300 003530 ZZ2252=ZZ2252+ZZ2252 -+006300 007260 ZZ2252=ZZ2252+ZZ2252 -+006300 016540 ZZ2252=ZZ2252+ZZ2252 -+006300 035300 ZZ2252=ZZ2252+ZZ2252 -+006300 072600 ZZ2252=ZZ2252+ZZ2252 -+006300 165400 ZZ2252=ZZ2252+ZZ2252 -+006300 000733 0 8192 -ZZ1252 -+006301 165400 0 ZZ2252 -- mark 7790, -372 /76 aqar -+006302 776426 ZZ2253=ZZ2253+ZZ2253 -+006302 775054 ZZ2253=ZZ2253+ZZ2253 -+006302 772130 ZZ2253=ZZ2253+ZZ2253 -+006302 764260 ZZ2253=ZZ2253+ZZ2253 -+006302 750540 ZZ2253=ZZ2253+ZZ2253 -+006302 721300 ZZ2253=ZZ2253+ZZ2253 -+006302 642600 ZZ2253=ZZ2253+ZZ2253 -+006302 505400 ZZ2253=ZZ2253+ZZ2253 -+006302 000622 0 8192 -ZZ1253 -+006303 505400 0 ZZ2253 - 006304 3q, -- mark 7849, 334 /54 pegs, markab -+006304 001234 ZZ2254=ZZ2254+ZZ2254 -+006304 002470 ZZ2254=ZZ2254+ZZ2254 -+006304 005160 ZZ2254=ZZ2254+ZZ2254 -+006304 012340 ZZ2254=ZZ2254+ZZ2254 -+006304 024700 ZZ2254=ZZ2254+ZZ2254 -+006304 051600 ZZ2254=ZZ2254+ZZ2254 -+006304 123400 ZZ2254=ZZ2254+ZZ2254 -+006304 247000 ZZ2254=ZZ2254+ZZ2254 -+006304 000527 0 8192 -ZZ1254 -+006305 247000 0 ZZ2254 - 006306 4j, -- mark 1, -143 /33 pisc -+006306 777340 ZZ2255=ZZ2255+ZZ2255 -+006306 776700 ZZ2255=ZZ2255+ZZ2255 -+006306 775600 ZZ2255=ZZ2255+ZZ2255 -+006306 773400 ZZ2255=ZZ2255+ZZ2255 -+006306 767000 ZZ2255=ZZ2255+ZZ2255 -+006306 756000 ZZ2255=ZZ2255+ZZ2255 -+006306 734000 ZZ2255=ZZ2255+ZZ2255 -+006306 670000 ZZ2255=ZZ2255+ZZ2255 -+006306 017777 0 8192 -ZZ1255 -+006307 670000 0 ZZ2255 -- mark 54, 447 /89 pegs -+006310 001576 ZZ2256=ZZ2256+ZZ2256 -+006310 003374 ZZ2256=ZZ2256+ZZ2256 -+006310 006770 ZZ2256=ZZ2256+ZZ2256 -+006310 015760 ZZ2256=ZZ2256+ZZ2256 -+006310 033740 ZZ2256=ZZ2256+ZZ2256 -+006310 067700 ZZ2256=ZZ2256+ZZ2256 -+006310 157600 ZZ2256=ZZ2256+ZZ2256 -+006310 337400 ZZ2256=ZZ2256+ZZ2256 -+006310 017712 0 8192 -ZZ1256 -+006311 337400 0 ZZ2256 -- mark 54, -443 /7 ceti -+006312 776210 ZZ2257=ZZ2257+ZZ2257 -+006312 774420 ZZ2257=ZZ2257+ZZ2257 -+006312 771040 ZZ2257=ZZ2257+ZZ2257 -+006312 762100 ZZ2257=ZZ2257+ZZ2257 -+006312 744200 ZZ2257=ZZ2257+ZZ2257 -+006312 710400 ZZ2257=ZZ2257+ZZ2257 -+006312 621000 ZZ2257=ZZ2257+ZZ2257 -+006312 442000 ZZ2257=ZZ2257+ZZ2257 -+006312 017712 0 8192 -ZZ1257 -+006313 442000 0 ZZ2257 -- mark 82, -214 /8 ceti -+006314 777122 ZZ2258=ZZ2258+ZZ2258 -+006314 776244 ZZ2258=ZZ2258+ZZ2258 -+006314 774510 ZZ2258=ZZ2258+ZZ2258 -+006314 771220 ZZ2258=ZZ2258+ZZ2258 -+006314 762440 ZZ2258=ZZ2258+ZZ2258 -+006314 745100 ZZ2258=ZZ2258+ZZ2258 -+006314 712200 ZZ2258=ZZ2258+ZZ2258 -+006314 624400 ZZ2258=ZZ2258+ZZ2258 -+006314 017656 0 8192 -ZZ1258 -+006315 624400 0 ZZ2258 -- mark 223, -254 /17 ceti -+006316 777002 ZZ2259=ZZ2259+ZZ2259 -+006316 776004 ZZ2259=ZZ2259+ZZ2259 -+006316 774010 ZZ2259=ZZ2259+ZZ2259 -+006316 770020 ZZ2259=ZZ2259+ZZ2259 -+006316 760040 ZZ2259=ZZ2259+ZZ2259 -+006316 740100 ZZ2259=ZZ2259+ZZ2259 -+006316 700200 ZZ2259=ZZ2259+ZZ2259 -+006316 600400 ZZ2259=ZZ2259+ZZ2259 -+006316 017441 0 8192 -ZZ1259 -+006317 600400 0 ZZ2259 -- mark 248, 160 /63 pisc -+006320 000500 ZZ2260=ZZ2260+ZZ2260 -+006320 001200 ZZ2260=ZZ2260+ZZ2260 -+006320 002400 ZZ2260=ZZ2260+ZZ2260 -+006320 005000 ZZ2260=ZZ2260+ZZ2260 -+006320 012000 ZZ2260=ZZ2260+ZZ2260 -+006320 024000 ZZ2260=ZZ2260+ZZ2260 -+006320 050000 ZZ2260=ZZ2260+ZZ2260 -+006320 120000 ZZ2260=ZZ2260+ZZ2260 -+006320 017410 0 8192 -ZZ1260 -+006321 120000 0 ZZ2260 -- mark 273, -38 /20 ceti -+006322 777662 ZZ2261=ZZ2261+ZZ2261 -+006322 777544 ZZ2261=ZZ2261+ZZ2261 -+006322 777310 ZZ2261=ZZ2261+ZZ2261 -+006322 776620 ZZ2261=ZZ2261+ZZ2261 -+006322 775440 ZZ2261=ZZ2261+ZZ2261 -+006322 773100 ZZ2261=ZZ2261+ZZ2261 -+006322 766200 ZZ2261=ZZ2261+ZZ2261 -+006322 754400 ZZ2261=ZZ2261+ZZ2261 -+006322 017357 0 8192 -ZZ1261 -+006323 754400 0 ZZ2261 -- mark 329, 167 /71 pisc -+006324 000516 ZZ2262=ZZ2262+ZZ2262 -+006324 001234 ZZ2262=ZZ2262+ZZ2262 -+006324 002470 ZZ2262=ZZ2262+ZZ2262 -+006324 005160 ZZ2262=ZZ2262+ZZ2262 -+006324 012340 ZZ2262=ZZ2262+ZZ2262 -+006324 024700 ZZ2262=ZZ2262+ZZ2262 -+006324 051600 ZZ2262=ZZ2262+ZZ2262 -+006324 123400 ZZ2262=ZZ2262+ZZ2262 -+006324 017267 0 8192 -ZZ1262 -+006325 123400 0 ZZ2262 -- mark 376, 467 /84 pisc -+006326 001646 ZZ2263=ZZ2263+ZZ2263 -+006326 003514 ZZ2263=ZZ2263+ZZ2263 -+006326 007230 ZZ2263=ZZ2263+ZZ2263 -+006326 016460 ZZ2263=ZZ2263+ZZ2263 -+006326 035140 ZZ2263=ZZ2263+ZZ2263 -+006326 072300 ZZ2263=ZZ2263+ZZ2263 -+006326 164600 ZZ2263=ZZ2263+ZZ2263 -+006326 351400 ZZ2263=ZZ2263+ZZ2263 -+006326 017210 0 8192 -ZZ1263 -+006327 351400 0 ZZ2263 -- mark 450, -198 /45 ceti -+006330 777162 ZZ2264=ZZ2264+ZZ2264 -+006330 776344 ZZ2264=ZZ2264+ZZ2264 -+006330 774710 ZZ2264=ZZ2264+ZZ2264 -+006330 771620 ZZ2264=ZZ2264+ZZ2264 -+006330 763440 ZZ2264=ZZ2264+ZZ2264 -+006330 747100 ZZ2264=ZZ2264+ZZ2264 -+006330 716200 ZZ2264=ZZ2264+ZZ2264 -+006330 634400 ZZ2264=ZZ2264+ZZ2264 -+006330 017076 0 8192 -ZZ1264 -+006331 634400 0 ZZ2264 -- mark 548, 113 /106 pisc -+006332 000342 ZZ2265=ZZ2265+ZZ2265 -+006332 000704 ZZ2265=ZZ2265+ZZ2265 -+006332 001610 ZZ2265=ZZ2265+ZZ2265 -+006332 003420 ZZ2265=ZZ2265+ZZ2265 -+006332 007040 ZZ2265=ZZ2265+ZZ2265 -+006332 016100 ZZ2265=ZZ2265+ZZ2265 -+006332 034200 ZZ2265=ZZ2265+ZZ2265 -+006332 070400 ZZ2265=ZZ2265+ZZ2265 -+006332 016734 0 8192 -ZZ1265 -+006333 070400 0 ZZ2265 -- mark 570, 197 /110 pisc -+006334 000612 ZZ2266=ZZ2266+ZZ2266 -+006334 001424 ZZ2266=ZZ2266+ZZ2266 -+006334 003050 ZZ2266=ZZ2266+ZZ2266 -+006334 006120 ZZ2266=ZZ2266+ZZ2266 -+006334 014240 ZZ2266=ZZ2266+ZZ2266 -+006334 030500 ZZ2266=ZZ2266+ZZ2266 -+006334 061200 ZZ2266=ZZ2266+ZZ2266 -+006334 142400 ZZ2266=ZZ2266+ZZ2266 -+006334 016706 0 8192 -ZZ1266 -+006335 142400 0 ZZ2266 -- mark 595, -255 /53 ceti -+006336 777000 ZZ2267=ZZ2267+ZZ2267 -+006336 776000 ZZ2267=ZZ2267+ZZ2267 -+006336 774000 ZZ2267=ZZ2267+ZZ2267 -+006336 770000 ZZ2267=ZZ2267+ZZ2267 -+006336 760000 ZZ2267=ZZ2267+ZZ2267 -+006336 740000 ZZ2267=ZZ2267+ZZ2267 -+006336 700000 ZZ2267=ZZ2267+ZZ2267 -+006336 600000 ZZ2267=ZZ2267+ZZ2267 -+006336 016655 0 8192 -ZZ1267 -+006337 600000 0 ZZ2267 -- mark 606, -247 /55 ceti -+006340 777020 ZZ2268=ZZ2268+ZZ2268 -+006340 776040 ZZ2268=ZZ2268+ZZ2268 -+006340 774100 ZZ2268=ZZ2268+ZZ2268 -+006340 770200 ZZ2268=ZZ2268+ZZ2268 -+006340 760400 ZZ2268=ZZ2268+ZZ2268 -+006340 741000 ZZ2268=ZZ2268+ZZ2268 -+006340 702000 ZZ2268=ZZ2268+ZZ2268 -+006340 604000 ZZ2268=ZZ2268+ZZ2268 -+006340 016642 0 8192 -ZZ1268 -+006341 604000 0 ZZ2268 -- mark 615, 428 / 5 arie -+006342 001530 ZZ2269=ZZ2269+ZZ2269 -+006342 003260 ZZ2269=ZZ2269+ZZ2269 -+006342 006540 ZZ2269=ZZ2269+ZZ2269 -+006342 015300 ZZ2269=ZZ2269+ZZ2269 -+006342 032600 ZZ2269=ZZ2269+ZZ2269 -+006342 065400 ZZ2269=ZZ2269+ZZ2269 -+006342 153000 ZZ2269=ZZ2269+ZZ2269 -+006342 326000 ZZ2269=ZZ2269+ZZ2269 -+006342 016631 0 8192 -ZZ1269 -+006343 326000 0 ZZ2269 -- mark 617, 61 /14 pisc -+006344 000172 ZZ2270=ZZ2270+ZZ2270 -+006344 000364 ZZ2270=ZZ2270+ZZ2270 -+006344 000750 ZZ2270=ZZ2270+ZZ2270 -+006344 001720 ZZ2270=ZZ2270+ZZ2270 -+006344 003640 ZZ2270=ZZ2270+ZZ2270 -+006344 007500 ZZ2270=ZZ2270+ZZ2270 -+006344 017200 ZZ2270=ZZ2270+ZZ2270 -+006344 036400 ZZ2270=ZZ2270+ZZ2270 -+006344 016627 0 8192 -ZZ1270 -+006345 036400 0 ZZ2270 -- mark 656, -491 /59 ceti -+006346 776050 ZZ2271=ZZ2271+ZZ2271 -+006346 774120 ZZ2271=ZZ2271+ZZ2271 -+006346 770240 ZZ2271=ZZ2271+ZZ2271 -+006346 760500 ZZ2271=ZZ2271+ZZ2271 -+006346 741200 ZZ2271=ZZ2271+ZZ2271 -+006346 702400 ZZ2271=ZZ2271+ZZ2271 -+006346 605000 ZZ2271=ZZ2271+ZZ2271 -+006346 412000 ZZ2271=ZZ2271+ZZ2271 -+006346 016560 0 8192 -ZZ1271 -+006347 412000 0 ZZ2271 -- mark 665, 52 /113 pisc -+006350 000150 ZZ2272=ZZ2272+ZZ2272 -+006350 000320 ZZ2272=ZZ2272+ZZ2272 -+006350 000640 ZZ2272=ZZ2272+ZZ2272 -+006350 001500 ZZ2272=ZZ2272+ZZ2272 -+006350 003200 ZZ2272=ZZ2272+ZZ2272 -+006350 006400 ZZ2272=ZZ2272+ZZ2272 -+006350 015000 ZZ2272=ZZ2272+ZZ2272 -+006350 032000 ZZ2272=ZZ2272+ZZ2272 -+006350 016547 0 8192 -ZZ1272 -+006351 032000 0 ZZ2272 -- mark 727, 191 /65 ceti -+006352 000576 ZZ2273=ZZ2273+ZZ2273 -+006352 001374 ZZ2273=ZZ2273+ZZ2273 -+006352 002770 ZZ2273=ZZ2273+ZZ2273 -+006352 005760 ZZ2273=ZZ2273+ZZ2273 -+006352 013740 ZZ2273=ZZ2273+ZZ2273 -+006352 027700 ZZ2273=ZZ2273+ZZ2273 -+006352 057600 ZZ2273=ZZ2273+ZZ2273 -+006352 137400 ZZ2273=ZZ2273+ZZ2273 -+006352 016451 0 8192 -ZZ1273 -+006353 137400 0 ZZ2273 -- mark 803, -290 /72 ceti -+006354 776672 ZZ2274=ZZ2274+ZZ2274 -+006354 775564 ZZ2274=ZZ2274+ZZ2274 -+006354 773350 ZZ2274=ZZ2274+ZZ2274 -+006354 766720 ZZ2274=ZZ2274+ZZ2274 -+006354 755640 ZZ2274=ZZ2274+ZZ2274 -+006354 733500 ZZ2274=ZZ2274+ZZ2274 -+006354 667200 ZZ2274=ZZ2274+ZZ2274 -+006354 556400 ZZ2274=ZZ2274+ZZ2274 -+006354 016335 0 8192 -ZZ1274 -+006355 556400 0 ZZ2274 -- mark 813, 182 /73 ceti -+006356 000554 ZZ2275=ZZ2275+ZZ2275 -+006356 001330 ZZ2275=ZZ2275+ZZ2275 -+006356 002660 ZZ2275=ZZ2275+ZZ2275 -+006356 005540 ZZ2275=ZZ2275+ZZ2275 -+006356 013300 ZZ2275=ZZ2275+ZZ2275 -+006356 026600 ZZ2275=ZZ2275+ZZ2275 -+006356 055400 ZZ2275=ZZ2275+ZZ2275 -+006356 133000 ZZ2275=ZZ2275+ZZ2275 -+006356 016323 0 8192 -ZZ1275 -+006357 133000 0 ZZ2275 -- mark 838, -357 /76 ceti -+006360 776464 ZZ2276=ZZ2276+ZZ2276 -+006360 775150 ZZ2276=ZZ2276+ZZ2276 -+006360 772320 ZZ2276=ZZ2276+ZZ2276 -+006360 764640 ZZ2276=ZZ2276+ZZ2276 -+006360 751500 ZZ2276=ZZ2276+ZZ2276 -+006360 723200 ZZ2276=ZZ2276+ZZ2276 -+006360 646400 ZZ2276=ZZ2276+ZZ2276 -+006360 515000 ZZ2276=ZZ2276+ZZ2276 -+006360 016272 0 8192 -ZZ1276 -+006361 515000 0 ZZ2276 -- mark 878, -2 /82 ceti -+006362 777772 ZZ2277=ZZ2277+ZZ2277 -+006362 777764 ZZ2277=ZZ2277+ZZ2277 -+006362 777750 ZZ2277=ZZ2277+ZZ2277 -+006362 777720 ZZ2277=ZZ2277+ZZ2277 -+006362 777640 ZZ2277=ZZ2277+ZZ2277 -+006362 777500 ZZ2277=ZZ2277+ZZ2277 -+006362 777200 ZZ2277=ZZ2277+ZZ2277 -+006362 776400 ZZ2277=ZZ2277+ZZ2277 -+006362 016222 0 8192 -ZZ1277 -+006363 776400 0 ZZ2277 -- mark 907, -340 /89 ceti -+006364 776526 ZZ2278=ZZ2278+ZZ2278 -+006364 775254 ZZ2278=ZZ2278+ZZ2278 -+006364 772530 ZZ2278=ZZ2278+ZZ2278 -+006364 765260 ZZ2278=ZZ2278+ZZ2278 -+006364 752540 ZZ2278=ZZ2278+ZZ2278 -+006364 725300 ZZ2278=ZZ2278+ZZ2278 -+006364 652600 ZZ2278=ZZ2278+ZZ2278 -+006364 525400 ZZ2278=ZZ2278+ZZ2278 -+006364 016165 0 8192 -ZZ1278 -+006365 525400 0 ZZ2278 -- mark 908, 221 /87 ceti -+006366 000672 ZZ2279=ZZ2279+ZZ2279 -+006366 001564 ZZ2279=ZZ2279+ZZ2279 -+006366 003350 ZZ2279=ZZ2279+ZZ2279 -+006366 006720 ZZ2279=ZZ2279+ZZ2279 -+006366 015640 ZZ2279=ZZ2279+ZZ2279 -+006366 033500 ZZ2279=ZZ2279+ZZ2279 -+006366 067200 ZZ2279=ZZ2279+ZZ2279 -+006366 156400 ZZ2279=ZZ2279+ZZ2279 -+006366 016164 0 8192 -ZZ1279 -+006367 156400 0 ZZ2279 -- mark 913, -432 / 1 erid -+006370 776236 ZZ2280=ZZ2280+ZZ2280 -+006370 774474 ZZ2280=ZZ2280+ZZ2280 -+006370 771170 ZZ2280=ZZ2280+ZZ2280 -+006370 762360 ZZ2280=ZZ2280+ZZ2280 -+006370 744740 ZZ2280=ZZ2280+ZZ2280 -+006370 711700 ZZ2280=ZZ2280+ZZ2280 -+006370 623600 ZZ2280=ZZ2280+ZZ2280 -+006370 447400 ZZ2280=ZZ2280+ZZ2280 -+006370 016157 0 8192 -ZZ1280 -+006371 447400 0 ZZ2280 -- mark 947, -487 / 2 erid -+006372 776060 ZZ2281=ZZ2281+ZZ2281 -+006372 774140 ZZ2281=ZZ2281+ZZ2281 -+006372 770300 ZZ2281=ZZ2281+ZZ2281 -+006372 760600 ZZ2281=ZZ2281+ZZ2281 -+006372 741400 ZZ2281=ZZ2281+ZZ2281 -+006372 703000 ZZ2281=ZZ2281+ZZ2281 -+006372 606000 ZZ2281=ZZ2281+ZZ2281 -+006372 414000 ZZ2281=ZZ2281+ZZ2281 -+006372 016115 0 8192 -ZZ1281 -+006373 414000 0 ZZ2281 -- mark 976, -212 / 3 erid -+006374 777126 ZZ2282=ZZ2282+ZZ2282 -+006374 776254 ZZ2282=ZZ2282+ZZ2282 -+006374 774530 ZZ2282=ZZ2282+ZZ2282 -+006374 771260 ZZ2282=ZZ2282+ZZ2282 -+006374 762540 ZZ2282=ZZ2282+ZZ2282 -+006374 745300 ZZ2282=ZZ2282+ZZ2282 -+006374 712600 ZZ2282=ZZ2282+ZZ2282 -+006374 625400 ZZ2282=ZZ2282+ZZ2282 -+006374 016060 0 8192 -ZZ1282 -+006375 625400 0 ZZ2282 -- mark 992, 194 /91 ceti -+006376 000604 ZZ2283=ZZ2283+ZZ2283 -+006376 001410 ZZ2283=ZZ2283+ZZ2283 -+006376 003020 ZZ2283=ZZ2283+ZZ2283 -+006376 006040 ZZ2283=ZZ2283+ZZ2283 -+006376 014100 ZZ2283=ZZ2283+ZZ2283 -+006376 030200 ZZ2283=ZZ2283+ZZ2283 -+006376 060400 ZZ2283=ZZ2283+ZZ2283 -+006376 141000 ZZ2283=ZZ2283+ZZ2283 -+006376 016040 0 8192 -ZZ1283 -+006377 141000 0 ZZ2283 -- mark 1058, 440 /57 arie -+006400 001560 ZZ2284=ZZ2284+ZZ2284 -+006400 003340 ZZ2284=ZZ2284+ZZ2284 -+006400 006700 ZZ2284=ZZ2284+ZZ2284 -+006400 015600 ZZ2284=ZZ2284+ZZ2284 -+006400 033400 ZZ2284=ZZ2284+ZZ2284 -+006400 067000 ZZ2284=ZZ2284+ZZ2284 -+006400 156000 ZZ2284=ZZ2284+ZZ2284 -+006400 334000 ZZ2284=ZZ2284+ZZ2284 -+006400 015736 0 8192 -ZZ1284 -+006401 334000 0 ZZ2284 -- mark 1076, 470 /58 arie -+006402 001654 ZZ2285=ZZ2285+ZZ2285 -+006402 003530 ZZ2285=ZZ2285+ZZ2285 -+006402 007260 ZZ2285=ZZ2285+ZZ2285 -+006402 016540 ZZ2285=ZZ2285+ZZ2285 -+006402 035300 ZZ2285=ZZ2285+ZZ2285 -+006402 072600 ZZ2285=ZZ2285+ZZ2285 -+006402 165400 ZZ2285=ZZ2285+ZZ2285 -+006402 353000 ZZ2285=ZZ2285+ZZ2285 -+006402 015714 0 8192 -ZZ1285 -+006403 353000 0 ZZ2285 -- mark 1087, -209 /13 erid -+006404 777134 ZZ2286=ZZ2286+ZZ2286 -+006404 776270 ZZ2286=ZZ2286+ZZ2286 -+006404 774560 ZZ2286=ZZ2286+ZZ2286 -+006404 771340 ZZ2286=ZZ2286+ZZ2286 -+006404 762700 ZZ2286=ZZ2286+ZZ2286 -+006404 745600 ZZ2286=ZZ2286+ZZ2286 -+006404 713400 ZZ2286=ZZ2286+ZZ2286 -+006404 627000 ZZ2286=ZZ2286+ZZ2286 -+006404 015701 0 8192 -ZZ1286 -+006405 627000 0 ZZ2286 -- mark 1104, 68 /96 ceti -+006406 000210 ZZ2287=ZZ2287+ZZ2287 -+006406 000420 ZZ2287=ZZ2287+ZZ2287 -+006406 001040 ZZ2287=ZZ2287+ZZ2287 -+006406 002100 ZZ2287=ZZ2287+ZZ2287 -+006406 004200 ZZ2287=ZZ2287+ZZ2287 -+006406 010400 ZZ2287=ZZ2287+ZZ2287 -+006406 021000 ZZ2287=ZZ2287+ZZ2287 -+006406 042000 ZZ2287=ZZ2287+ZZ2287 -+006406 015660 0 8192 -ZZ1287 -+006407 042000 0 ZZ2287 -- mark 1110, -503 /16 erid -+006410 776020 ZZ2288=ZZ2288+ZZ2288 -+006410 774040 ZZ2288=ZZ2288+ZZ2288 -+006410 770100 ZZ2288=ZZ2288+ZZ2288 -+006410 760200 ZZ2288=ZZ2288+ZZ2288 -+006410 740400 ZZ2288=ZZ2288+ZZ2288 -+006410 701000 ZZ2288=ZZ2288+ZZ2288 -+006410 602000 ZZ2288=ZZ2288+ZZ2288 -+006410 404000 ZZ2288=ZZ2288+ZZ2288 -+006410 015652 0 8192 -ZZ1288 -+006411 404000 0 ZZ2288 -- mark 1135, 198 / 1 taur -+006412 000614 ZZ2289=ZZ2289+ZZ2289 -+006412 001430 ZZ2289=ZZ2289+ZZ2289 -+006412 003060 ZZ2289=ZZ2289+ZZ2289 -+006412 006140 ZZ2289=ZZ2289+ZZ2289 -+006412 014300 ZZ2289=ZZ2289+ZZ2289 -+006412 030600 ZZ2289=ZZ2289+ZZ2289 -+006412 061400 ZZ2289=ZZ2289+ZZ2289 -+006412 143000 ZZ2289=ZZ2289+ZZ2289 -+006412 015621 0 8192 -ZZ1289 -+006413 143000 0 ZZ2289 -- mark 1148, 214 / 2 taur -+006414 000654 ZZ2290=ZZ2290+ZZ2290 -+006414 001530 ZZ2290=ZZ2290+ZZ2290 -+006414 003260 ZZ2290=ZZ2290+ZZ2290 -+006414 006540 ZZ2290=ZZ2290+ZZ2290 -+006414 015300 ZZ2290=ZZ2290+ZZ2290 -+006414 032600 ZZ2290=ZZ2290+ZZ2290 -+006414 065400 ZZ2290=ZZ2290+ZZ2290 -+006414 153000 ZZ2290=ZZ2290+ZZ2290 -+006414 015604 0 8192 -ZZ1290 -+006415 153000 0 ZZ2290 -- mark 1168, 287 / 5 taur -+006416 001076 ZZ2291=ZZ2291+ZZ2291 -+006416 002174 ZZ2291=ZZ2291+ZZ2291 -+006416 004370 ZZ2291=ZZ2291+ZZ2291 -+006416 010760 ZZ2291=ZZ2291+ZZ2291 -+006416 021740 ZZ2291=ZZ2291+ZZ2291 -+006416 043700 ZZ2291=ZZ2291+ZZ2291 -+006416 107600 ZZ2291=ZZ2291+ZZ2291 -+006416 217400 ZZ2291=ZZ2291+ZZ2291 -+006416 015560 0 8192 -ZZ1291 -+006417 217400 0 ZZ2291 -- mark 1170, -123 /17 erid -+006420 777410 ZZ2292=ZZ2292+ZZ2292 -+006420 777020 ZZ2292=ZZ2292+ZZ2292 -+006420 776040 ZZ2292=ZZ2292+ZZ2292 -+006420 774100 ZZ2292=ZZ2292+ZZ2292 -+006420 770200 ZZ2292=ZZ2292+ZZ2292 -+006420 760400 ZZ2292=ZZ2292+ZZ2292 -+006420 741000 ZZ2292=ZZ2292+ZZ2292 -+006420 702000 ZZ2292=ZZ2292+ZZ2292 -+006420 015556 0 8192 -ZZ1292 -+006421 702000 0 ZZ2292 -- mark 1185, -223 /18 erid -+006422 777100 ZZ2293=ZZ2293+ZZ2293 -+006422 776200 ZZ2293=ZZ2293+ZZ2293 -+006422 774400 ZZ2293=ZZ2293+ZZ2293 -+006422 771000 ZZ2293=ZZ2293+ZZ2293 -+006422 762000 ZZ2293=ZZ2293+ZZ2293 -+006422 744000 ZZ2293=ZZ2293+ZZ2293 -+006422 710000 ZZ2293=ZZ2293+ZZ2293 -+006422 620000 ZZ2293=ZZ2293+ZZ2293 -+006422 015537 0 8192 -ZZ1293 -+006423 620000 0 ZZ2293 -- mark 1191, -500 /19 erid -+006424 776026 ZZ2294=ZZ2294+ZZ2294 -+006424 774054 ZZ2294=ZZ2294+ZZ2294 -+006424 770130 ZZ2294=ZZ2294+ZZ2294 -+006424 760260 ZZ2294=ZZ2294+ZZ2294 -+006424 740540 ZZ2294=ZZ2294+ZZ2294 -+006424 701300 ZZ2294=ZZ2294+ZZ2294 -+006424 602600 ZZ2294=ZZ2294+ZZ2294 -+006424 405400 ZZ2294=ZZ2294+ZZ2294 -+006424 015531 0 8192 -ZZ1294 -+006425 405400 0 ZZ2294 -- mark 1205, 2 /10 taur -+006426 000004 ZZ2295=ZZ2295+ZZ2295 -+006426 000010 ZZ2295=ZZ2295+ZZ2295 -+006426 000020 ZZ2295=ZZ2295+ZZ2295 -+006426 000040 ZZ2295=ZZ2295+ZZ2295 -+006426 000100 ZZ2295=ZZ2295+ZZ2295 -+006426 000200 ZZ2295=ZZ2295+ZZ2295 -+006426 000400 ZZ2295=ZZ2295+ZZ2295 -+006426 001000 ZZ2295=ZZ2295+ZZ2295 -+006426 015513 0 8192 -ZZ1295 -+006427 001000 0 ZZ2295 -- mark 1260, -283 /26 erid -+006430 776710 ZZ2296=ZZ2296+ZZ2296 -+006430 775620 ZZ2296=ZZ2296+ZZ2296 -+006430 773440 ZZ2296=ZZ2296+ZZ2296 -+006430 767100 ZZ2296=ZZ2296+ZZ2296 -+006430 756200 ZZ2296=ZZ2296+ZZ2296 -+006430 734400 ZZ2296=ZZ2296+ZZ2296 -+006430 671000 ZZ2296=ZZ2296+ZZ2296 -+006430 562000 ZZ2296=ZZ2296+ZZ2296 -+006430 015424 0 8192 -ZZ1296 -+006431 562000 0 ZZ2296 -- mark 1304, -74 /32 erid -+006432 777552 ZZ2297=ZZ2297+ZZ2297 -+006432 777324 ZZ2297=ZZ2297+ZZ2297 -+006432 776650 ZZ2297=ZZ2297+ZZ2297 -+006432 775520 ZZ2297=ZZ2297+ZZ2297 -+006432 773240 ZZ2297=ZZ2297+ZZ2297 -+006432 766500 ZZ2297=ZZ2297+ZZ2297 -+006432 755200 ZZ2297=ZZ2297+ZZ2297 -+006432 732400 ZZ2297=ZZ2297+ZZ2297 -+006432 015350 0 8192 -ZZ1297 -+006433 732400 0 ZZ2297 -- mark 1338, 278 /35 taur -+006434 001054 ZZ2298=ZZ2298+ZZ2298 -+006434 002130 ZZ2298=ZZ2298+ZZ2298 -+006434 004260 ZZ2298=ZZ2298+ZZ2298 -+006434 010540 ZZ2298=ZZ2298+ZZ2298 -+006434 021300 ZZ2298=ZZ2298+ZZ2298 -+006434 042600 ZZ2298=ZZ2298+ZZ2298 -+006434 105400 ZZ2298=ZZ2298+ZZ2298 -+006434 213000 ZZ2298=ZZ2298+ZZ2298 -+006434 015306 0 8192 -ZZ1298 -+006435 213000 0 ZZ2298 -- mark 1353, 130 /38 taur -+006436 000404 ZZ2299=ZZ2299+ZZ2299 -+006436 001010 ZZ2299=ZZ2299+ZZ2299 -+006436 002020 ZZ2299=ZZ2299+ZZ2299 -+006436 004040 ZZ2299=ZZ2299+ZZ2299 -+006436 010100 ZZ2299=ZZ2299+ZZ2299 -+006436 020200 ZZ2299=ZZ2299+ZZ2299 -+006436 040400 ZZ2299=ZZ2299+ZZ2299 -+006436 101000 ZZ2299=ZZ2299+ZZ2299 -+006436 015267 0 8192 -ZZ1299 -+006437 101000 0 ZZ2299 -- mark 1358, 497 /37 taur -+006440 001742 ZZ2300=ZZ2300+ZZ2300 -+006440 003704 ZZ2300=ZZ2300+ZZ2300 -+006440 007610 ZZ2300=ZZ2300+ZZ2300 -+006440 017420 ZZ2300=ZZ2300+ZZ2300 -+006440 037040 ZZ2300=ZZ2300+ZZ2300 -+006440 076100 ZZ2300=ZZ2300+ZZ2300 -+006440 174200 ZZ2300=ZZ2300+ZZ2300 -+006440 370400 ZZ2300=ZZ2300+ZZ2300 -+006440 015262 0 8192 -ZZ1300 -+006441 370400 0 ZZ2300 -- mark 1405, -162 /38 erid -+006442 777272 ZZ2301=ZZ2301+ZZ2301 -+006442 776564 ZZ2301=ZZ2301+ZZ2301 -+006442 775350 ZZ2301=ZZ2301+ZZ2301 -+006442 772720 ZZ2301=ZZ2301+ZZ2301 -+006442 765640 ZZ2301=ZZ2301+ZZ2301 -+006442 753500 ZZ2301=ZZ2301+ZZ2301 -+006442 727200 ZZ2301=ZZ2301+ZZ2301 -+006442 656400 ZZ2301=ZZ2301+ZZ2301 -+006442 015203 0 8192 -ZZ1301 -+006443 656400 0 ZZ2301 -- mark 1414, 205 /47 taur -+006444 000632 ZZ2302=ZZ2302+ZZ2302 -+006444 001464 ZZ2302=ZZ2302+ZZ2302 -+006444 003150 ZZ2302=ZZ2302+ZZ2302 -+006444 006320 ZZ2302=ZZ2302+ZZ2302 -+006444 014640 ZZ2302=ZZ2302+ZZ2302 -+006444 031500 ZZ2302=ZZ2302+ZZ2302 -+006444 063200 ZZ2302=ZZ2302+ZZ2302 -+006444 146400 ZZ2302=ZZ2302+ZZ2302 -+006444 015172 0 8192 -ZZ1302 -+006445 146400 0 ZZ2302 -- mark 1423, 197 /49 taur -+006446 000612 ZZ2303=ZZ2303+ZZ2303 -+006446 001424 ZZ2303=ZZ2303+ZZ2303 -+006446 003050 ZZ2303=ZZ2303+ZZ2303 -+006446 006120 ZZ2303=ZZ2303+ZZ2303 -+006446 014240 ZZ2303=ZZ2303+ZZ2303 -+006446 030500 ZZ2303=ZZ2303+ZZ2303 -+006446 061200 ZZ2303=ZZ2303+ZZ2303 -+006446 142400 ZZ2303=ZZ2303+ZZ2303 -+006446 015161 0 8192 -ZZ1303 -+006447 142400 0 ZZ2303 -- mark 1426, -178 /40 erid -+006450 777232 ZZ2304=ZZ2304+ZZ2304 -+006450 776464 ZZ2304=ZZ2304+ZZ2304 -+006450 775150 ZZ2304=ZZ2304+ZZ2304 -+006450 772320 ZZ2304=ZZ2304+ZZ2304 -+006450 764640 ZZ2304=ZZ2304+ZZ2304 -+006450 751500 ZZ2304=ZZ2304+ZZ2304 -+006450 723200 ZZ2304=ZZ2304+ZZ2304 -+006450 646400 ZZ2304=ZZ2304+ZZ2304 -+006450 015156 0 8192 -ZZ1304 -+006451 646400 0 ZZ2304 -- mark 1430, 463 /50 taur -+006452 001636 ZZ2305=ZZ2305+ZZ2305 -+006452 003474 ZZ2305=ZZ2305+ZZ2305 -+006452 007170 ZZ2305=ZZ2305+ZZ2305 -+006452 016360 ZZ2305=ZZ2305+ZZ2305 -+006452 034740 ZZ2305=ZZ2305+ZZ2305 -+006452 071700 ZZ2305=ZZ2305+ZZ2305 -+006452 163600 ZZ2305=ZZ2305+ZZ2305 -+006452 347400 ZZ2305=ZZ2305+ZZ2305 -+006452 015152 0 8192 -ZZ1305 -+006453 347400 0 ZZ2305 -- mark 1446, 350 /54 taur -+006454 001274 ZZ2306=ZZ2306+ZZ2306 -+006454 002570 ZZ2306=ZZ2306+ZZ2306 -+006454 005360 ZZ2306=ZZ2306+ZZ2306 -+006454 012740 ZZ2306=ZZ2306+ZZ2306 -+006454 025700 ZZ2306=ZZ2306+ZZ2306 -+006454 053600 ZZ2306=ZZ2306+ZZ2306 -+006454 127400 ZZ2306=ZZ2306+ZZ2306 -+006454 257000 ZZ2306=ZZ2306+ZZ2306 -+006454 015132 0 8192 -ZZ1306 -+006455 257000 0 ZZ2306 -- mark 1463, 394 /61 taur -+006456 001424 ZZ2307=ZZ2307+ZZ2307 -+006456 003050 ZZ2307=ZZ2307+ZZ2307 -+006456 006120 ZZ2307=ZZ2307+ZZ2307 -+006456 014240 ZZ2307=ZZ2307+ZZ2307 -+006456 030500 ZZ2307=ZZ2307+ZZ2307 -+006456 061200 ZZ2307=ZZ2307+ZZ2307 -+006456 142400 ZZ2307=ZZ2307+ZZ2307 -+006456 305000 ZZ2307=ZZ2307+ZZ2307 -+006456 015111 0 8192 -ZZ1307 -+006457 305000 0 ZZ2307 -- mark 1470, 392 /64 taur -+006460 001420 ZZ2308=ZZ2308+ZZ2308 -+006460 003040 ZZ2308=ZZ2308+ZZ2308 -+006460 006100 ZZ2308=ZZ2308+ZZ2308 -+006460 014200 ZZ2308=ZZ2308+ZZ2308 -+006460 030400 ZZ2308=ZZ2308+ZZ2308 -+006460 061000 ZZ2308=ZZ2308+ZZ2308 -+006460 142000 ZZ2308=ZZ2308+ZZ2308 -+006460 304000 ZZ2308=ZZ2308+ZZ2308 -+006460 015102 0 8192 -ZZ1308 -+006461 304000 0 ZZ2308 -- mark 1476, 502 /65 taur -+006462 001754 ZZ2309=ZZ2309+ZZ2309 -+006462 003730 ZZ2309=ZZ2309+ZZ2309 -+006462 007660 ZZ2309=ZZ2309+ZZ2309 -+006462 017540 ZZ2309=ZZ2309+ZZ2309 -+006462 037300 ZZ2309=ZZ2309+ZZ2309 -+006462 076600 ZZ2309=ZZ2309+ZZ2309 -+006462 175400 ZZ2309=ZZ2309+ZZ2309 -+006462 373000 ZZ2309=ZZ2309+ZZ2309 -+006462 015074 0 8192 -ZZ1309 -+006463 373000 0 ZZ2309 -- mark 1477, 403 /68 taur -+006464 001446 ZZ2310=ZZ2310+ZZ2310 -+006464 003114 ZZ2310=ZZ2310+ZZ2310 -+006464 006230 ZZ2310=ZZ2310+ZZ2310 -+006464 014460 ZZ2310=ZZ2310+ZZ2310 -+006464 031140 ZZ2310=ZZ2310+ZZ2310 -+006464 062300 ZZ2310=ZZ2310+ZZ2310 -+006464 144600 ZZ2310=ZZ2310+ZZ2310 -+006464 311400 ZZ2310=ZZ2310+ZZ2310 -+006464 015073 0 8192 -ZZ1310 -+006465 311400 0 ZZ2310 -- mark 1483, 350 /71 taur -+006466 001274 ZZ2311=ZZ2311+ZZ2311 -+006466 002570 ZZ2311=ZZ2311+ZZ2311 -+006466 005360 ZZ2311=ZZ2311+ZZ2311 -+006466 012740 ZZ2311=ZZ2311+ZZ2311 -+006466 025700 ZZ2311=ZZ2311+ZZ2311 -+006466 053600 ZZ2311=ZZ2311+ZZ2311 -+006466 127400 ZZ2311=ZZ2311+ZZ2311 -+006466 257000 ZZ2311=ZZ2311+ZZ2311 -+006466 015065 0 8192 -ZZ1311 -+006467 257000 0 ZZ2311 -- mark 1485, 330 /73 taur -+006470 001224 ZZ2312=ZZ2312+ZZ2312 -+006470 002450 ZZ2312=ZZ2312+ZZ2312 -+006470 005120 ZZ2312=ZZ2312+ZZ2312 -+006470 012240 ZZ2312=ZZ2312+ZZ2312 -+006470 024500 ZZ2312=ZZ2312+ZZ2312 -+006470 051200 ZZ2312=ZZ2312+ZZ2312 -+006470 122400 ZZ2312=ZZ2312+ZZ2312 -+006470 245000 ZZ2312=ZZ2312+ZZ2312 -+006470 015063 0 8192 -ZZ1312 -+006471 245000 0 ZZ2312 -- mark 1495, 358 /77 taur -+006472 001314 ZZ2313=ZZ2313+ZZ2313 -+006472 002630 ZZ2313=ZZ2313+ZZ2313 -+006472 005460 ZZ2313=ZZ2313+ZZ2313 -+006472 013140 ZZ2313=ZZ2313+ZZ2313 -+006472 026300 ZZ2313=ZZ2313+ZZ2313 -+006472 054600 ZZ2313=ZZ2313+ZZ2313 -+006472 131400 ZZ2313=ZZ2313+ZZ2313 -+006472 263000 ZZ2313=ZZ2313+ZZ2313 -+006472 015051 0 8192 -ZZ1313 -+006473 263000 0 ZZ2313 -- mark 1507, 364 / -+006474 001330 ZZ2314=ZZ2314+ZZ2314 -+006474 002660 ZZ2314=ZZ2314+ZZ2314 -+006474 005540 ZZ2314=ZZ2314+ZZ2314 -+006474 013300 ZZ2314=ZZ2314+ZZ2314 -+006474 026600 ZZ2314=ZZ2314+ZZ2314 -+006474 055400 ZZ2314=ZZ2314+ZZ2314 -+006474 133000 ZZ2314=ZZ2314+ZZ2314 -+006474 266000 ZZ2314=ZZ2314+ZZ2314 -+006474 015035 0 8192 -ZZ1314 -+006475 266000 0 ZZ2314 -- mark 1518, -6 /45 erid -+006476 777762 ZZ2315=ZZ2315+ZZ2315 -+006476 777744 ZZ2315=ZZ2315+ZZ2315 -+006476 777710 ZZ2315=ZZ2315+ZZ2315 -+006476 777620 ZZ2315=ZZ2315+ZZ2315 -+006476 777440 ZZ2315=ZZ2315+ZZ2315 -+006476 777100 ZZ2315=ZZ2315+ZZ2315 -+006476 776200 ZZ2315=ZZ2315+ZZ2315 -+006476 774400 ZZ2315=ZZ2315+ZZ2315 -+006476 015022 0 8192 -ZZ1315 -+006477 774400 0 ZZ2315 -- mark 1526, 333 /86 taur -+006500 001232 ZZ2316=ZZ2316+ZZ2316 -+006500 002464 ZZ2316=ZZ2316+ZZ2316 -+006500 005150 ZZ2316=ZZ2316+ZZ2316 -+006500 012320 ZZ2316=ZZ2316+ZZ2316 -+006500 024640 ZZ2316=ZZ2316+ZZ2316 -+006500 051500 ZZ2316=ZZ2316+ZZ2316 -+006500 123200 ZZ2316=ZZ2316+ZZ2316 -+006500 246400 ZZ2316=ZZ2316+ZZ2316 -+006500 015012 0 8192 -ZZ1316 -+006501 246400 0 ZZ2316 -- mark 1537, 226 /88 taur -+006502 000704 ZZ2317=ZZ2317+ZZ2317 -+006502 001610 ZZ2317=ZZ2317+ZZ2317 -+006502 003420 ZZ2317=ZZ2317+ZZ2317 -+006502 007040 ZZ2317=ZZ2317+ZZ2317 -+006502 016100 ZZ2317=ZZ2317+ZZ2317 -+006502 034200 ZZ2317=ZZ2317+ZZ2317 -+006502 070400 ZZ2317=ZZ2317+ZZ2317 -+006502 161000 ZZ2317=ZZ2317+ZZ2317 -+006502 014777 0 8192 -ZZ1317 -+006503 161000 0 ZZ2317 -- mark 1544, -81 /48 erid -+006504 777534 ZZ2318=ZZ2318+ZZ2318 -+006504 777270 ZZ2318=ZZ2318+ZZ2318 -+006504 776560 ZZ2318=ZZ2318+ZZ2318 -+006504 775340 ZZ2318=ZZ2318+ZZ2318 -+006504 772700 ZZ2318=ZZ2318+ZZ2318 -+006504 765600 ZZ2318=ZZ2318+ZZ2318 -+006504 753400 ZZ2318=ZZ2318+ZZ2318 -+006504 727000 ZZ2318=ZZ2318+ZZ2318 -+006504 014770 0 8192 -ZZ1318 -+006505 727000 0 ZZ2318 -- mark 1551, 280 /90 taur -+006506 001060 ZZ2319=ZZ2319+ZZ2319 -+006506 002140 ZZ2319=ZZ2319+ZZ2319 -+006506 004300 ZZ2319=ZZ2319+ZZ2319 -+006506 010600 ZZ2319=ZZ2319+ZZ2319 -+006506 021400 ZZ2319=ZZ2319+ZZ2319 -+006506 043000 ZZ2319=ZZ2319+ZZ2319 -+006506 106000 ZZ2319=ZZ2319+ZZ2319 -+006506 214000 ZZ2319=ZZ2319+ZZ2319 -+006506 014761 0 8192 -ZZ1319 -+006507 214000 0 ZZ2319 -- mark 1556, 358 /92 taur -+006510 001314 ZZ2320=ZZ2320+ZZ2320 -+006510 002630 ZZ2320=ZZ2320+ZZ2320 -+006510 005460 ZZ2320=ZZ2320+ZZ2320 -+006510 013140 ZZ2320=ZZ2320+ZZ2320 -+006510 026300 ZZ2320=ZZ2320+ZZ2320 -+006510 054600 ZZ2320=ZZ2320+ZZ2320 -+006510 131400 ZZ2320=ZZ2320+ZZ2320 -+006510 263000 ZZ2320=ZZ2320+ZZ2320 -+006510 014754 0 8192 -ZZ1320 -+006511 263000 0 ZZ2320 -- mark 1557, -330 /53 erid -+006512 776552 ZZ2321=ZZ2321+ZZ2321 -+006512 775324 ZZ2321=ZZ2321+ZZ2321 -+006512 772650 ZZ2321=ZZ2321+ZZ2321 -+006512 765520 ZZ2321=ZZ2321+ZZ2321 -+006512 753240 ZZ2321=ZZ2321+ZZ2321 -+006512 726500 ZZ2321=ZZ2321+ZZ2321 -+006512 655200 ZZ2321=ZZ2321+ZZ2321 -+006512 532400 ZZ2321=ZZ2321+ZZ2321 -+006512 014753 0 8192 -ZZ1321 -+006513 532400 0 ZZ2321 -- mark 1571, -452 /54 erid -+006514 776166 ZZ2322=ZZ2322+ZZ2322 -+006514 774354 ZZ2322=ZZ2322+ZZ2322 -+006514 770730 ZZ2322=ZZ2322+ZZ2322 -+006514 761660 ZZ2322=ZZ2322+ZZ2322 -+006514 743540 ZZ2322=ZZ2322+ZZ2322 -+006514 707300 ZZ2322=ZZ2322+ZZ2322 -+006514 616600 ZZ2322=ZZ2322+ZZ2322 -+006514 435400 ZZ2322=ZZ2322+ZZ2322 -+006514 014735 0 8192 -ZZ1322 -+006515 435400 0 ZZ2322 -- mark 1596, -78 /57 erid -+006516 777542 ZZ2323=ZZ2323+ZZ2323 -+006516 777304 ZZ2323=ZZ2323+ZZ2323 -+006516 776610 ZZ2323=ZZ2323+ZZ2323 -+006516 775420 ZZ2323=ZZ2323+ZZ2323 -+006516 773040 ZZ2323=ZZ2323+ZZ2323 -+006516 766100 ZZ2323=ZZ2323+ZZ2323 -+006516 754200 ZZ2323=ZZ2323+ZZ2323 -+006516 730400 ZZ2323=ZZ2323+ZZ2323 -+006516 014704 0 8192 -ZZ1323 -+006517 730400 0 ZZ2323 -- mark 1622, 199 / 2 orio -+006520 000616 ZZ2324=ZZ2324+ZZ2324 -+006520 001434 ZZ2324=ZZ2324+ZZ2324 -+006520 003070 ZZ2324=ZZ2324+ZZ2324 -+006520 006160 ZZ2324=ZZ2324+ZZ2324 -+006520 014340 ZZ2324=ZZ2324+ZZ2324 -+006520 030700 ZZ2324=ZZ2324+ZZ2324 -+006520 061600 ZZ2324=ZZ2324+ZZ2324 -+006520 143400 ZZ2324=ZZ2324+ZZ2324 -+006520 014652 0 8192 -ZZ1324 -+006521 143400 0 ZZ2324 -- mark 1626, 124 / 3 orio -+006522 000370 ZZ2325=ZZ2325+ZZ2325 -+006522 000760 ZZ2325=ZZ2325+ZZ2325 -+006522 001740 ZZ2325=ZZ2325+ZZ2325 -+006522 003700 ZZ2325=ZZ2325+ZZ2325 -+006522 007600 ZZ2325=ZZ2325+ZZ2325 -+006522 017400 ZZ2325=ZZ2325+ZZ2325 -+006522 037000 ZZ2325=ZZ2325+ZZ2325 -+006522 076000 ZZ2325=ZZ2325+ZZ2325 -+006522 014646 0 8192 -ZZ1325 -+006523 076000 0 ZZ2325 -- mark 1638, -128 /61 erid -+006524 777376 ZZ2326=ZZ2326+ZZ2326 -+006524 776774 ZZ2326=ZZ2326+ZZ2326 -+006524 775770 ZZ2326=ZZ2326+ZZ2326 -+006524 773760 ZZ2326=ZZ2326+ZZ2326 -+006524 767740 ZZ2326=ZZ2326+ZZ2326 -+006524 757700 ZZ2326=ZZ2326+ZZ2326 -+006524 737600 ZZ2326=ZZ2326+ZZ2326 -+006524 677400 ZZ2326=ZZ2326+ZZ2326 -+006524 014632 0 8192 -ZZ1326 -+006525 677400 0 ZZ2326 -- mark 1646, 228 / 7 orio -+006526 000710 ZZ2327=ZZ2327+ZZ2327 -+006526 001620 ZZ2327=ZZ2327+ZZ2327 -+006526 003440 ZZ2327=ZZ2327+ZZ2327 -+006526 007100 ZZ2327=ZZ2327+ZZ2327 -+006526 016200 ZZ2327=ZZ2327+ZZ2327 -+006526 034400 ZZ2327=ZZ2327+ZZ2327 -+006526 071000 ZZ2327=ZZ2327+ZZ2327 -+006526 162000 ZZ2327=ZZ2327+ZZ2327 -+006526 014622 0 8192 -ZZ1327 -+006527 162000 0 ZZ2327 -- mark 1654, 304 / 9 orio -+006530 001140 ZZ2328=ZZ2328+ZZ2328 -+006530 002300 ZZ2328=ZZ2328+ZZ2328 -+006530 004600 ZZ2328=ZZ2328+ZZ2328 -+006530 011400 ZZ2328=ZZ2328+ZZ2328 -+006530 023000 ZZ2328=ZZ2328+ZZ2328 -+006530 046000 ZZ2328=ZZ2328+ZZ2328 -+006530 114000 ZZ2328=ZZ2328+ZZ2328 -+006530 230000 ZZ2328=ZZ2328+ZZ2328 -+006530 014612 0 8192 -ZZ1328 -+006531 230000 0 ZZ2328 -- mark 1669, 36 /10 orio -+006532 000110 ZZ2329=ZZ2329+ZZ2329 -+006532 000220 ZZ2329=ZZ2329+ZZ2329 -+006532 000440 ZZ2329=ZZ2329+ZZ2329 -+006532 001100 ZZ2329=ZZ2329+ZZ2329 -+006532 002200 ZZ2329=ZZ2329+ZZ2329 -+006532 004400 ZZ2329=ZZ2329+ZZ2329 -+006532 011000 ZZ2329=ZZ2329+ZZ2329 -+006532 022000 ZZ2329=ZZ2329+ZZ2329 -+006532 014573 0 8192 -ZZ1329 -+006533 022000 0 ZZ2329 -- mark 1680, -289 /64 erid -+006534 776674 ZZ2330=ZZ2330+ZZ2330 -+006534 775570 ZZ2330=ZZ2330+ZZ2330 -+006534 773360 ZZ2330=ZZ2330+ZZ2330 -+006534 766740 ZZ2330=ZZ2330+ZZ2330 -+006534 755700 ZZ2330=ZZ2330+ZZ2330 -+006534 733600 ZZ2330=ZZ2330+ZZ2330 -+006534 667400 ZZ2330=ZZ2330+ZZ2330 -+006534 557000 ZZ2330=ZZ2330+ZZ2330 -+006534 014560 0 8192 -ZZ1330 -+006535 557000 0 ZZ2330 -- mark 1687, -167 /65 erid -+006536 777260 ZZ2331=ZZ2331+ZZ2331 -+006536 776540 ZZ2331=ZZ2331+ZZ2331 -+006536 775300 ZZ2331=ZZ2331+ZZ2331 -+006536 772600 ZZ2331=ZZ2331+ZZ2331 -+006536 765400 ZZ2331=ZZ2331+ZZ2331 -+006536 753000 ZZ2331=ZZ2331+ZZ2331 -+006536 726000 ZZ2331=ZZ2331+ZZ2331 -+006536 654000 ZZ2331=ZZ2331+ZZ2331 -+006536 014551 0 8192 -ZZ1331 -+006537 654000 0 ZZ2331 -- mark 1690, -460 / -+006540 776146 ZZ2332=ZZ2332+ZZ2332 -+006540 774314 ZZ2332=ZZ2332+ZZ2332 -+006540 770630 ZZ2332=ZZ2332+ZZ2332 -+006540 761460 ZZ2332=ZZ2332+ZZ2332 -+006540 743140 ZZ2332=ZZ2332+ZZ2332 -+006540 706300 ZZ2332=ZZ2332+ZZ2332 -+006540 614600 ZZ2332=ZZ2332+ZZ2332 -+006540 431400 ZZ2332=ZZ2332+ZZ2332 -+006540 014546 0 8192 -ZZ1332 -+006541 431400 0 ZZ2332 -- mark 1690, 488 /102 taur -+006542 001720 ZZ2333=ZZ2333+ZZ2333 -+006542 003640 ZZ2333=ZZ2333+ZZ2333 -+006542 007500 ZZ2333=ZZ2333+ZZ2333 -+006542 017200 ZZ2333=ZZ2333+ZZ2333 -+006542 036400 ZZ2333=ZZ2333+ZZ2333 -+006542 075000 ZZ2333=ZZ2333+ZZ2333 -+006542 172000 ZZ2333=ZZ2333+ZZ2333 -+006542 364000 ZZ2333=ZZ2333+ZZ2333 -+006542 014546 0 8192 -ZZ1333 -+006543 364000 0 ZZ2333 -- mark 1700, 347 /11 orio -+006544 001266 ZZ2334=ZZ2334+ZZ2334 -+006544 002554 ZZ2334=ZZ2334+ZZ2334 -+006544 005330 ZZ2334=ZZ2334+ZZ2334 -+006544 012660 ZZ2334=ZZ2334+ZZ2334 -+006544 025540 ZZ2334=ZZ2334+ZZ2334 -+006544 053300 ZZ2334=ZZ2334+ZZ2334 -+006544 126600 ZZ2334=ZZ2334+ZZ2334 -+006544 255400 ZZ2334=ZZ2334+ZZ2334 -+006544 014534 0 8192 -ZZ1334 -+006545 255400 0 ZZ2334 -- mark 1729, 352 /15 orio -+006546 001300 ZZ2335=ZZ2335+ZZ2335 -+006546 002600 ZZ2335=ZZ2335+ZZ2335 -+006546 005400 ZZ2335=ZZ2335+ZZ2335 -+006546 013000 ZZ2335=ZZ2335+ZZ2335 -+006546 026000 ZZ2335=ZZ2335+ZZ2335 -+006546 054000 ZZ2335=ZZ2335+ZZ2335 -+006546 130000 ZZ2335=ZZ2335+ZZ2335 -+006546 260000 ZZ2335=ZZ2335+ZZ2335 -+006546 014477 0 8192 -ZZ1335 -+006547 260000 0 ZZ2335 -- mark 1732, -202 /69 erid -+006550 777152 ZZ2336=ZZ2336+ZZ2336 -+006550 776324 ZZ2336=ZZ2336+ZZ2336 -+006550 774650 ZZ2336=ZZ2336+ZZ2336 -+006550 771520 ZZ2336=ZZ2336+ZZ2336 -+006550 763240 ZZ2336=ZZ2336+ZZ2336 -+006550 746500 ZZ2336=ZZ2336+ZZ2336 -+006550 715200 ZZ2336=ZZ2336+ZZ2336 -+006550 632400 ZZ2336=ZZ2336+ZZ2336 -+006550 014474 0 8192 -ZZ1336 -+006551 632400 0 ZZ2336 -- mark 1750, -273 / 3 leps -+006552 776734 ZZ2337=ZZ2337+ZZ2337 -+006552 775670 ZZ2337=ZZ2337+ZZ2337 -+006552 773560 ZZ2337=ZZ2337+ZZ2337 -+006552 767340 ZZ2337=ZZ2337+ZZ2337 -+006552 756700 ZZ2337=ZZ2337+ZZ2337 -+006552 735600 ZZ2337=ZZ2337+ZZ2337 -+006552 673400 ZZ2337=ZZ2337+ZZ2337 -+006552 567000 ZZ2337=ZZ2337+ZZ2337 -+006552 014452 0 8192 -ZZ1337 -+006553 567000 0 ZZ2337 -- mark 1753, 63 /17 orio -+006554 000176 ZZ2338=ZZ2338+ZZ2338 -+006554 000374 ZZ2338=ZZ2338+ZZ2338 -+006554 000770 ZZ2338=ZZ2338+ZZ2338 -+006554 001760 ZZ2338=ZZ2338+ZZ2338 -+006554 003740 ZZ2338=ZZ2338+ZZ2338 -+006554 007700 ZZ2338=ZZ2338+ZZ2338 -+006554 017600 ZZ2338=ZZ2338+ZZ2338 -+006554 037400 ZZ2338=ZZ2338+ZZ2338 -+006554 014447 0 8192 -ZZ1338 -+006555 037400 0 ZZ2338 -- mark 1756, -297 / 4 leps -+006556 776654 ZZ2339=ZZ2339+ZZ2339 -+006556 775530 ZZ2339=ZZ2339+ZZ2339 -+006556 773260 ZZ2339=ZZ2339+ZZ2339 -+006556 766540 ZZ2339=ZZ2339+ZZ2339 -+006556 755300 ZZ2339=ZZ2339+ZZ2339 -+006556 732600 ZZ2339=ZZ2339+ZZ2339 -+006556 665400 ZZ2339=ZZ2339+ZZ2339 -+006556 553000 ZZ2339=ZZ2339+ZZ2339 -+006556 014444 0 8192 -ZZ1339 -+006557 553000 0 ZZ2339 -- mark 1792, -302 / 6 leps -+006560 776642 ZZ2340=ZZ2340+ZZ2340 -+006560 775504 ZZ2340=ZZ2340+ZZ2340 -+006560 773210 ZZ2340=ZZ2340+ZZ2340 -+006560 766420 ZZ2340=ZZ2340+ZZ2340 -+006560 755040 ZZ2340=ZZ2340+ZZ2340 -+006560 732100 ZZ2340=ZZ2340+ZZ2340 -+006560 664200 ZZ2340=ZZ2340+ZZ2340 -+006560 550400 ZZ2340=ZZ2340+ZZ2340 -+006560 014400 0 8192 -ZZ1340 -+006561 550400 0 ZZ2340 -- mark 1799, -486 / -+006562 776062 ZZ2341=ZZ2341+ZZ2341 -+006562 774144 ZZ2341=ZZ2341+ZZ2341 -+006562 770310 ZZ2341=ZZ2341+ZZ2341 -+006562 760620 ZZ2341=ZZ2341+ZZ2341 -+006562 741440 ZZ2341=ZZ2341+ZZ2341 -+006562 703100 ZZ2341=ZZ2341+ZZ2341 -+006562 606200 ZZ2341=ZZ2341+ZZ2341 -+006562 414400 ZZ2341=ZZ2341+ZZ2341 -+006562 014371 0 8192 -ZZ1341 -+006563 414400 0 ZZ2341 -- mark 1801, -11 /22 orio -+006564 777750 ZZ2342=ZZ2342+ZZ2342 -+006564 777720 ZZ2342=ZZ2342+ZZ2342 -+006564 777640 ZZ2342=ZZ2342+ZZ2342 -+006564 777500 ZZ2342=ZZ2342+ZZ2342 -+006564 777200 ZZ2342=ZZ2342+ZZ2342 -+006564 776400 ZZ2342=ZZ2342+ZZ2342 -+006564 775000 ZZ2342=ZZ2342+ZZ2342 -+006564 772000 ZZ2342=ZZ2342+ZZ2342 -+006564 014367 0 8192 -ZZ1342 -+006565 772000 0 ZZ2342 -- mark 1807, 79 /23 orio -+006566 000236 ZZ2343=ZZ2343+ZZ2343 -+006566 000474 ZZ2343=ZZ2343+ZZ2343 -+006566 001170 ZZ2343=ZZ2343+ZZ2343 -+006566 002360 ZZ2343=ZZ2343+ZZ2343 -+006566 004740 ZZ2343=ZZ2343+ZZ2343 -+006566 011700 ZZ2343=ZZ2343+ZZ2343 -+006566 023600 ZZ2343=ZZ2343+ZZ2343 -+006566 047400 ZZ2343=ZZ2343+ZZ2343 -+006566 014361 0 8192 -ZZ1343 -+006567 047400 0 ZZ2343 -- mark 1816, -180 /29 orio -+006570 777226 ZZ2344=ZZ2344+ZZ2344 -+006570 776454 ZZ2344=ZZ2344+ZZ2344 -+006570 775130 ZZ2344=ZZ2344+ZZ2344 -+006570 772260 ZZ2344=ZZ2344+ZZ2344 -+006570 764540 ZZ2344=ZZ2344+ZZ2344 -+006570 751300 ZZ2344=ZZ2344+ZZ2344 -+006570 722600 ZZ2344=ZZ2344+ZZ2344 -+006570 645400 ZZ2344=ZZ2344+ZZ2344 -+006570 014350 0 8192 -ZZ1344 -+006571 645400 0 ZZ2344 -- mark 1818, 40 /25 orio -+006572 000120 ZZ2345=ZZ2345+ZZ2345 -+006572 000240 ZZ2345=ZZ2345+ZZ2345 -+006572 000500 ZZ2345=ZZ2345+ZZ2345 -+006572 001200 ZZ2345=ZZ2345+ZZ2345 -+006572 002400 ZZ2345=ZZ2345+ZZ2345 -+006572 005000 ZZ2345=ZZ2345+ZZ2345 -+006572 012000 ZZ2345=ZZ2345+ZZ2345 -+006572 024000 ZZ2345=ZZ2345+ZZ2345 -+006572 014346 0 8192 -ZZ1345 -+006573 024000 0 ZZ2345 -- mark 1830, 497 /114 taur -+006574 001742 ZZ2346=ZZ2346+ZZ2346 -+006574 003704 ZZ2346=ZZ2346+ZZ2346 -+006574 007610 ZZ2346=ZZ2346+ZZ2346 -+006574 017420 ZZ2346=ZZ2346+ZZ2346 -+006574 037040 ZZ2346=ZZ2346+ZZ2346 -+006574 076100 ZZ2346=ZZ2346+ZZ2346 -+006574 174200 ZZ2346=ZZ2346+ZZ2346 -+006574 370400 ZZ2346=ZZ2346+ZZ2346 -+006574 014332 0 8192 -ZZ1346 -+006575 370400 0 ZZ2346 -- mark 1830, 69 /30 orio -+006576 000212 ZZ2347=ZZ2347+ZZ2347 -+006576 000424 ZZ2347=ZZ2347+ZZ2347 -+006576 001050 ZZ2347=ZZ2347+ZZ2347 -+006576 002120 ZZ2347=ZZ2347+ZZ2347 -+006576 004240 ZZ2347=ZZ2347+ZZ2347 -+006576 010500 ZZ2347=ZZ2347+ZZ2347 -+006576 021200 ZZ2347=ZZ2347+ZZ2347 -+006576 042400 ZZ2347=ZZ2347+ZZ2347 -+006576 014332 0 8192 -ZZ1347 -+006577 042400 0 ZZ2347 -- mark 1851, 134 /32 orio -+006600 000414 ZZ2348=ZZ2348+ZZ2348 -+006600 001030 ZZ2348=ZZ2348+ZZ2348 -+006600 002060 ZZ2348=ZZ2348+ZZ2348 -+006600 004140 ZZ2348=ZZ2348+ZZ2348 -+006600 010300 ZZ2348=ZZ2348+ZZ2348 -+006600 020600 ZZ2348=ZZ2348+ZZ2348 -+006600 041400 ZZ2348=ZZ2348+ZZ2348 -+006600 103000 ZZ2348=ZZ2348+ZZ2348 -+006600 014305 0 8192 -ZZ1348 -+006601 103000 0 ZZ2348 -- mark 1857, 421 /119 taur -+006602 001512 ZZ2349=ZZ2349+ZZ2349 -+006602 003224 ZZ2349=ZZ2349+ZZ2349 -+006602 006450 ZZ2349=ZZ2349+ZZ2349 -+006602 015120 ZZ2349=ZZ2349+ZZ2349 -+006602 032240 ZZ2349=ZZ2349+ZZ2349 -+006602 064500 ZZ2349=ZZ2349+ZZ2349 -+006602 151200 ZZ2349=ZZ2349+ZZ2349 -+006602 322400 ZZ2349=ZZ2349+ZZ2349 -+006602 014277 0 8192 -ZZ1349 -+006603 322400 0 ZZ2349 -- mark 1861, -168 /36 orio -+006604 777256 ZZ2350=ZZ2350+ZZ2350 -+006604 776534 ZZ2350=ZZ2350+ZZ2350 -+006604 775270 ZZ2350=ZZ2350+ZZ2350 -+006604 772560 ZZ2350=ZZ2350+ZZ2350 -+006604 765340 ZZ2350=ZZ2350+ZZ2350 -+006604 752700 ZZ2350=ZZ2350+ZZ2350 -+006604 725600 ZZ2350=ZZ2350+ZZ2350 -+006604 653400 ZZ2350=ZZ2350+ZZ2350 -+006604 014273 0 8192 -ZZ1350 -+006605 653400 0 ZZ2350 -- mark 1874, 214 /37 orio -+006606 000654 ZZ2351=ZZ2351+ZZ2351 -+006606 001530 ZZ2351=ZZ2351+ZZ2351 -+006606 003260 ZZ2351=ZZ2351+ZZ2351 -+006606 006540 ZZ2351=ZZ2351+ZZ2351 -+006606 015300 ZZ2351=ZZ2351+ZZ2351 -+006606 032600 ZZ2351=ZZ2351+ZZ2351 -+006606 065400 ZZ2351=ZZ2351+ZZ2351 -+006606 153000 ZZ2351=ZZ2351+ZZ2351 -+006606 014256 0 8192 -ZZ1351 -+006607 153000 0 ZZ2351 -- mark 1878, -132 / -+006610 777366 ZZ2352=ZZ2352+ZZ2352 -+006610 776754 ZZ2352=ZZ2352+ZZ2352 -+006610 775730 ZZ2352=ZZ2352+ZZ2352 -+006610 773660 ZZ2352=ZZ2352+ZZ2352 -+006610 767540 ZZ2352=ZZ2352+ZZ2352 -+006610 757300 ZZ2352=ZZ2352+ZZ2352 -+006610 736600 ZZ2352=ZZ2352+ZZ2352 -+006610 675400 ZZ2352=ZZ2352+ZZ2352 -+006610 014252 0 8192 -ZZ1352 -+006611 675400 0 ZZ2352 -- mark 1880, -112 /42 orio -+006612 777436 ZZ2353=ZZ2353+ZZ2353 -+006612 777074 ZZ2353=ZZ2353+ZZ2353 -+006612 776170 ZZ2353=ZZ2353+ZZ2353 -+006612 774360 ZZ2353=ZZ2353+ZZ2353 -+006612 770740 ZZ2353=ZZ2353+ZZ2353 -+006612 761700 ZZ2353=ZZ2353+ZZ2353 -+006612 743600 ZZ2353=ZZ2353+ZZ2353 -+006612 707400 ZZ2353=ZZ2353+ZZ2353 -+006612 014250 0 8192 -ZZ1353 -+006613 707400 0 ZZ2353 -- mark 1885, 210 /40 orio -+006614 000644 ZZ2354=ZZ2354+ZZ2354 -+006614 001510 ZZ2354=ZZ2354+ZZ2354 -+006614 003220 ZZ2354=ZZ2354+ZZ2354 -+006614 006440 ZZ2354=ZZ2354+ZZ2354 -+006614 015100 ZZ2354=ZZ2354+ZZ2354 -+006614 032200 ZZ2354=ZZ2354+ZZ2354 -+006614 064400 ZZ2354=ZZ2354+ZZ2354 -+006614 151000 ZZ2354=ZZ2354+ZZ2354 -+006614 014243 0 8192 -ZZ1354 -+006615 151000 0 ZZ2354 -- mark 1899,-60 /48 orio -+006616 777606 ZZ2355=ZZ2355+ZZ2355 -+006616 777414 ZZ2355=ZZ2355+ZZ2355 -+006616 777030 ZZ2355=ZZ2355+ZZ2355 -+006616 776060 ZZ2355=ZZ2355+ZZ2355 -+006616 774140 ZZ2355=ZZ2355+ZZ2355 -+006616 770300 ZZ2355=ZZ2355+ZZ2355 -+006616 760600 ZZ2355=ZZ2355+ZZ2355 -+006616 741400 ZZ2355=ZZ2355+ZZ2355 -+006616 014225 0 8192 -ZZ1355 -+006617 741400 0 ZZ2355 -- mark 1900, 93 /47 orio -+006620 000272 ZZ2356=ZZ2356+ZZ2356 -+006620 000564 ZZ2356=ZZ2356+ZZ2356 -+006620 001350 ZZ2356=ZZ2356+ZZ2356 -+006620 002720 ZZ2356=ZZ2356+ZZ2356 -+006620 005640 ZZ2356=ZZ2356+ZZ2356 -+006620 013500 ZZ2356=ZZ2356+ZZ2356 -+006620 027200 ZZ2356=ZZ2356+ZZ2356 -+006620 056400 ZZ2356=ZZ2356+ZZ2356 -+006620 014224 0 8192 -ZZ1356 -+006621 056400 0 ZZ2356 -- mark 1900, -165 /49 orio -+006622 777264 ZZ2357=ZZ2357+ZZ2357 -+006622 776550 ZZ2357=ZZ2357+ZZ2357 -+006622 775320 ZZ2357=ZZ2357+ZZ2357 -+006622 772640 ZZ2357=ZZ2357+ZZ2357 -+006622 765500 ZZ2357=ZZ2357+ZZ2357 -+006622 753200 ZZ2357=ZZ2357+ZZ2357 -+006622 726400 ZZ2357=ZZ2357+ZZ2357 -+006622 655000 ZZ2357=ZZ2357+ZZ2357 -+006622 014224 0 8192 -ZZ1357 -+006623 655000 0 ZZ2357 -- mark 1909, 375 /126 taur -+006624 001356 ZZ2358=ZZ2358+ZZ2358 -+006624 002734 ZZ2358=ZZ2358+ZZ2358 -+006624 005670 ZZ2358=ZZ2358+ZZ2358 -+006624 013560 ZZ2358=ZZ2358+ZZ2358 -+006624 027340 ZZ2358=ZZ2358+ZZ2358 -+006624 056700 ZZ2358=ZZ2358+ZZ2358 -+006624 135600 ZZ2358=ZZ2358+ZZ2358 -+006624 273400 ZZ2358=ZZ2358+ZZ2358 -+006624 014213 0 8192 -ZZ1358 -+006625 273400 0 ZZ2358 -- mark 1936, -511 /13 leps -+006626 776000 ZZ2359=ZZ2359+ZZ2359 -+006626 774000 ZZ2359=ZZ2359+ZZ2359 -+006626 770000 ZZ2359=ZZ2359+ZZ2359 -+006626 760000 ZZ2359=ZZ2359+ZZ2359 -+006626 740000 ZZ2359=ZZ2359+ZZ2359 -+006626 700000 ZZ2359=ZZ2359+ZZ2359 -+006626 600000 ZZ2359=ZZ2359+ZZ2359 -+006626 400000 ZZ2359=ZZ2359+ZZ2359 -+006626 014160 0 8192 -ZZ1359 -+006627 400000 0 ZZ2359 -- mark 1957, 287 /134 taur -+006630 001076 ZZ2360=ZZ2360+ZZ2360 -+006630 002174 ZZ2360=ZZ2360+ZZ2360 -+006630 004370 ZZ2360=ZZ2360+ZZ2360 -+006630 010760 ZZ2360=ZZ2360+ZZ2360 -+006630 021740 ZZ2360=ZZ2360+ZZ2360 -+006630 043700 ZZ2360=ZZ2360+ZZ2360 -+006630 107600 ZZ2360=ZZ2360+ZZ2360 -+006630 217400 ZZ2360=ZZ2360+ZZ2360 -+006630 014133 0 8192 -ZZ1360 -+006631 217400 0 ZZ2360 -- mark 1974, -475 /15 leps -+006632 776110 ZZ2361=ZZ2361+ZZ2361 -+006632 774220 ZZ2361=ZZ2361+ZZ2361 -+006632 770440 ZZ2361=ZZ2361+ZZ2361 -+006632 761100 ZZ2361=ZZ2361+ZZ2361 -+006632 742200 ZZ2361=ZZ2361+ZZ2361 -+006632 704400 ZZ2361=ZZ2361+ZZ2361 -+006632 611000 ZZ2361=ZZ2361+ZZ2361 -+006632 422000 ZZ2361=ZZ2361+ZZ2361 -+006632 014112 0 8192 -ZZ1361 -+006633 422000 0 ZZ2361 -- mark 1982, 461 /54 orio -+006634 001632 ZZ2362=ZZ2362+ZZ2362 -+006634 003464 ZZ2362=ZZ2362+ZZ2362 -+006634 007150 ZZ2362=ZZ2362+ZZ2362 -+006634 016320 ZZ2362=ZZ2362+ZZ2362 -+006634 034640 ZZ2362=ZZ2362+ZZ2362 -+006634 071500 ZZ2362=ZZ2362+ZZ2362 -+006634 163200 ZZ2362=ZZ2362+ZZ2362 -+006634 346400 ZZ2362=ZZ2362+ZZ2362 -+006634 014102 0 8192 -ZZ1362 -+006635 346400 0 ZZ2362 -- mark 2002, -323 /16 leps -+006636 776570 ZZ2363=ZZ2363+ZZ2363 -+006636 775360 ZZ2363=ZZ2363+ZZ2363 -+006636 772740 ZZ2363=ZZ2363+ZZ2363 -+006636 765700 ZZ2363=ZZ2363+ZZ2363 -+006636 753600 ZZ2363=ZZ2363+ZZ2363 -+006636 727400 ZZ2363=ZZ2363+ZZ2363 -+006636 657000 ZZ2363=ZZ2363+ZZ2363 -+006636 536000 ZZ2363=ZZ2363+ZZ2363 -+006636 014056 0 8192 -ZZ1363 -+006637 536000 0 ZZ2363 -- mark 2020, -70 / -+006640 777562 ZZ2364=ZZ2364+ZZ2364 -+006640 777344 ZZ2364=ZZ2364+ZZ2364 -+006640 776710 ZZ2364=ZZ2364+ZZ2364 -+006640 775620 ZZ2364=ZZ2364+ZZ2364 -+006640 773440 ZZ2364=ZZ2364+ZZ2364 -+006640 767100 ZZ2364=ZZ2364+ZZ2364 -+006640 756200 ZZ2364=ZZ2364+ZZ2364 -+006640 734400 ZZ2364=ZZ2364+ZZ2364 -+006640 014034 0 8192 -ZZ1364 -+006641 734400 0 ZZ2364 -- mark 2030, 220 /61 orio -+006642 000670 ZZ2365=ZZ2365+ZZ2365 -+006642 001560 ZZ2365=ZZ2365+ZZ2365 -+006642 003340 ZZ2365=ZZ2365+ZZ2365 -+006642 006700 ZZ2365=ZZ2365+ZZ2365 -+006642 015600 ZZ2365=ZZ2365+ZZ2365 -+006642 033400 ZZ2365=ZZ2365+ZZ2365 -+006642 067000 ZZ2365=ZZ2365+ZZ2365 -+006642 156000 ZZ2365=ZZ2365+ZZ2365 -+006642 014022 0 8192 -ZZ1365 -+006643 156000 0 ZZ2365 -- mark 2032, -241 / 3 mono -+006644 777034 ZZ2366=ZZ2366+ZZ2366 -+006644 776070 ZZ2366=ZZ2366+ZZ2366 -+006644 774160 ZZ2366=ZZ2366+ZZ2366 -+006644 770340 ZZ2366=ZZ2366+ZZ2366 -+006644 760700 ZZ2366=ZZ2366+ZZ2366 -+006644 741600 ZZ2366=ZZ2366+ZZ2366 -+006644 703400 ZZ2366=ZZ2366+ZZ2366 -+006644 607000 ZZ2366=ZZ2366+ZZ2366 -+006644 014020 0 8192 -ZZ1366 -+006645 607000 0 ZZ2366 -- mark 2037, 458 /62 orio -+006646 001624 ZZ2367=ZZ2367+ZZ2367 -+006646 003450 ZZ2367=ZZ2367+ZZ2367 -+006646 007120 ZZ2367=ZZ2367+ZZ2367 -+006646 016240 ZZ2367=ZZ2367+ZZ2367 -+006646 034500 ZZ2367=ZZ2367+ZZ2367 -+006646 071200 ZZ2367=ZZ2367+ZZ2367 -+006646 162400 ZZ2367=ZZ2367+ZZ2367 -+006646 345000 ZZ2367=ZZ2367+ZZ2367 -+006646 014013 0 8192 -ZZ1367 -+006647 345000 0 ZZ2367 -- mark 2057, -340 /18 leps -+006650 776526 ZZ2368=ZZ2368+ZZ2368 -+006650 775254 ZZ2368=ZZ2368+ZZ2368 -+006650 772530 ZZ2368=ZZ2368+ZZ2368 -+006650 765260 ZZ2368=ZZ2368+ZZ2368 -+006650 752540 ZZ2368=ZZ2368+ZZ2368 -+006650 725300 ZZ2368=ZZ2368+ZZ2368 -+006650 652600 ZZ2368=ZZ2368+ZZ2368 -+006650 525400 ZZ2368=ZZ2368+ZZ2368 -+006650 013767 0 8192 -ZZ1368 -+006651 525400 0 ZZ2368 -- mark 2059, 336 /67 orio -+006652 001240 ZZ2369=ZZ2369+ZZ2369 -+006652 002500 ZZ2369=ZZ2369+ZZ2369 -+006652 005200 ZZ2369=ZZ2369+ZZ2369 -+006652 012400 ZZ2369=ZZ2369+ZZ2369 -+006652 025000 ZZ2369=ZZ2369+ZZ2369 -+006652 052000 ZZ2369=ZZ2369+ZZ2369 -+006652 124000 ZZ2369=ZZ2369+ZZ2369 -+006652 250000 ZZ2369=ZZ2369+ZZ2369 -+006652 013765 0 8192 -ZZ1369 -+006653 250000 0 ZZ2369 -- mark 2084, 368 /69 orio -+006654 001340 ZZ2370=ZZ2370+ZZ2370 -+006654 002700 ZZ2370=ZZ2370+ZZ2370 -+006654 005600 ZZ2370=ZZ2370+ZZ2370 -+006654 013400 ZZ2370=ZZ2370+ZZ2370 -+006654 027000 ZZ2370=ZZ2370+ZZ2370 -+006654 056000 ZZ2370=ZZ2370+ZZ2370 -+006654 134000 ZZ2370=ZZ2370+ZZ2370 -+006654 270000 ZZ2370=ZZ2370+ZZ2370 -+006654 013734 0 8192 -ZZ1370 -+006655 270000 0 ZZ2370 -- mark 2084, 324 /70 orio -+006656 001210 ZZ2371=ZZ2371+ZZ2371 -+006656 002420 ZZ2371=ZZ2371+ZZ2371 -+006656 005040 ZZ2371=ZZ2371+ZZ2371 -+006656 012100 ZZ2371=ZZ2371+ZZ2371 -+006656 024200 ZZ2371=ZZ2371+ZZ2371 -+006656 050400 ZZ2371=ZZ2371+ZZ2371 -+006656 121000 ZZ2371=ZZ2371+ZZ2371 -+006656 242000 ZZ2371=ZZ2371+ZZ2371 -+006656 013734 0 8192 -ZZ1371 -+006657 242000 0 ZZ2371 -- mark 2105, -142 / 5 mono -+006660 777342 ZZ2372=ZZ2372+ZZ2372 -+006660 776704 ZZ2372=ZZ2372+ZZ2372 -+006660 775610 ZZ2372=ZZ2372+ZZ2372 -+006660 773420 ZZ2372=ZZ2372+ZZ2372 -+006660 767040 ZZ2372=ZZ2372+ZZ2372 -+006660 756100 ZZ2372=ZZ2372+ZZ2372 -+006660 734200 ZZ2372=ZZ2372+ZZ2372 -+006660 670400 ZZ2372=ZZ2372+ZZ2372 -+006660 013707 0 8192 -ZZ1372 -+006661 670400 0 ZZ2372 -- mark 2112, -311 / -+006662 776620 ZZ2373=ZZ2373+ZZ2373 -+006662 775440 ZZ2373=ZZ2373+ZZ2373 -+006662 773100 ZZ2373=ZZ2373+ZZ2373 -+006662 766200 ZZ2373=ZZ2373+ZZ2373 -+006662 754400 ZZ2373=ZZ2373+ZZ2373 -+006662 731000 ZZ2373=ZZ2373+ZZ2373 -+006662 662000 ZZ2373=ZZ2373+ZZ2373 -+006662 544000 ZZ2373=ZZ2373+ZZ2373 -+006662 013700 0 8192 -ZZ1373 -+006663 544000 0 ZZ2373 -- mark 2153, 106 / 8 mono -+006664 000324 ZZ2374=ZZ2374+ZZ2374 -+006664 000650 ZZ2374=ZZ2374+ZZ2374 -+006664 001520 ZZ2374=ZZ2374+ZZ2374 -+006664 003240 ZZ2374=ZZ2374+ZZ2374 -+006664 006500 ZZ2374=ZZ2374+ZZ2374 -+006664 015200 ZZ2374=ZZ2374+ZZ2374 -+006664 032400 ZZ2374=ZZ2374+ZZ2374 -+006664 065000 ZZ2374=ZZ2374+ZZ2374 -+006664 013627 0 8192 -ZZ1374 -+006665 065000 0 ZZ2374 -- mark 2179, 462 /18 gemi -+006666 001634 ZZ2375=ZZ2375+ZZ2375 -+006666 003470 ZZ2375=ZZ2375+ZZ2375 -+006666 007160 ZZ2375=ZZ2375+ZZ2375 -+006666 016340 ZZ2375=ZZ2375+ZZ2375 -+006666 034700 ZZ2375=ZZ2375+ZZ2375 -+006666 071600 ZZ2375=ZZ2375+ZZ2375 -+006666 163400 ZZ2375=ZZ2375+ZZ2375 -+006666 347000 ZZ2375=ZZ2375+ZZ2375 -+006666 013575 0 8192 -ZZ1375 -+006667 347000 0 ZZ2375 -- mark 2179, -107 /10 mono -+006670 777450 ZZ2376=ZZ2376+ZZ2376 -+006670 777120 ZZ2376=ZZ2376+ZZ2376 -+006670 776240 ZZ2376=ZZ2376+ZZ2376 -+006670 774500 ZZ2376=ZZ2376+ZZ2376 -+006670 771200 ZZ2376=ZZ2376+ZZ2376 -+006670 762400 ZZ2376=ZZ2376+ZZ2376 -+006670 745000 ZZ2376=ZZ2376+ZZ2376 -+006670 712000 ZZ2376=ZZ2376+ZZ2376 -+006670 013575 0 8192 -ZZ1376 -+006671 712000 0 ZZ2376 -- mark 2184, -159 /11 mono -+006672 777300 ZZ2377=ZZ2377+ZZ2377 -+006672 776600 ZZ2377=ZZ2377+ZZ2377 -+006672 775400 ZZ2377=ZZ2377+ZZ2377 -+006672 773000 ZZ2377=ZZ2377+ZZ2377 -+006672 766000 ZZ2377=ZZ2377+ZZ2377 -+006672 754000 ZZ2377=ZZ2377+ZZ2377 -+006672 730000 ZZ2377=ZZ2377+ZZ2377 -+006672 660000 ZZ2377=ZZ2377+ZZ2377 -+006672 013570 0 8192 -ZZ1377 -+006673 660000 0 ZZ2377 -- mark 2204, 168 /13 mono -+006674 000520 ZZ2378=ZZ2378+ZZ2378 -+006674 001240 ZZ2378=ZZ2378+ZZ2378 -+006674 002500 ZZ2378=ZZ2378+ZZ2378 -+006674 005200 ZZ2378=ZZ2378+ZZ2378 -+006674 012400 ZZ2378=ZZ2378+ZZ2378 -+006674 025000 ZZ2378=ZZ2378+ZZ2378 -+006674 052000 ZZ2378=ZZ2378+ZZ2378 -+006674 124000 ZZ2378=ZZ2378+ZZ2378 -+006674 013544 0 8192 -ZZ1378 -+006675 124000 0 ZZ2378 -- mark 2232, -436 / 7 cmaj -+006676 776226 ZZ2379=ZZ2379+ZZ2379 -+006676 774454 ZZ2379=ZZ2379+ZZ2379 -+006676 771130 ZZ2379=ZZ2379+ZZ2379 -+006676 762260 ZZ2379=ZZ2379+ZZ2379 -+006676 744540 ZZ2379=ZZ2379+ZZ2379 -+006676 711300 ZZ2379=ZZ2379+ZZ2379 -+006676 622600 ZZ2379=ZZ2379+ZZ2379 -+006676 445400 ZZ2379=ZZ2379+ZZ2379 -+006676 013510 0 8192 -ZZ1379 -+006677 445400 0 ZZ2379 -- mark 2239, -413 / 8 cmaj -+006700 776304 ZZ2380=ZZ2380+ZZ2380 -+006700 774610 ZZ2380=ZZ2380+ZZ2380 -+006700 771420 ZZ2380=ZZ2380+ZZ2380 -+006700 763040 ZZ2380=ZZ2380+ZZ2380 -+006700 746100 ZZ2380=ZZ2380+ZZ2380 -+006700 714200 ZZ2380=ZZ2380+ZZ2380 -+006700 630400 ZZ2380=ZZ2380+ZZ2380 -+006700 461000 ZZ2380=ZZ2380+ZZ2380 -+006700 013501 0 8192 -ZZ1380 -+006701 461000 0 ZZ2380 -- mark 2245, -320 / -+006702 776576 ZZ2381=ZZ2381+ZZ2381 -+006702 775374 ZZ2381=ZZ2381+ZZ2381 -+006702 772770 ZZ2381=ZZ2381+ZZ2381 -+006702 765760 ZZ2381=ZZ2381+ZZ2381 -+006702 753740 ZZ2381=ZZ2381+ZZ2381 -+006702 727700 ZZ2381=ZZ2381+ZZ2381 -+006702 657600 ZZ2381=ZZ2381+ZZ2381 -+006702 537400 ZZ2381=ZZ2381+ZZ2381 -+006702 013473 0 8192 -ZZ1381 -+006703 537400 0 ZZ2381 -- mark 2250, 227 /15 mono -+006704 000706 ZZ2382=ZZ2382+ZZ2382 -+006704 001614 ZZ2382=ZZ2382+ZZ2382 -+006704 003430 ZZ2382=ZZ2382+ZZ2382 -+006704 007060 ZZ2382=ZZ2382+ZZ2382 -+006704 016140 ZZ2382=ZZ2382+ZZ2382 -+006704 034300 ZZ2382=ZZ2382+ZZ2382 -+006704 070600 ZZ2382=ZZ2382+ZZ2382 -+006704 161400 ZZ2382=ZZ2382+ZZ2382 -+006704 013466 0 8192 -ZZ1382 -+006705 161400 0 ZZ2382 -- mark 2266, 303 /30 gemi -+006706 001136 ZZ2383=ZZ2383+ZZ2383 -+006706 002274 ZZ2383=ZZ2383+ZZ2383 -+006706 004570 ZZ2383=ZZ2383+ZZ2383 -+006706 011360 ZZ2383=ZZ2383+ZZ2383 -+006706 022740 ZZ2383=ZZ2383+ZZ2383 -+006706 045700 ZZ2383=ZZ2383+ZZ2383 -+006706 113600 ZZ2383=ZZ2383+ZZ2383 -+006706 227400 ZZ2383=ZZ2383+ZZ2383 -+006706 013446 0 8192 -ZZ1383 -+006707 227400 0 ZZ2383 -- mark 2291, 57 /18 mono -+006710 000162 ZZ2384=ZZ2384+ZZ2384 -+006710 000344 ZZ2384=ZZ2384+ZZ2384 -+006710 000710 ZZ2384=ZZ2384+ZZ2384 -+006710 001620 ZZ2384=ZZ2384+ZZ2384 -+006710 003440 ZZ2384=ZZ2384+ZZ2384 -+006710 007100 ZZ2384=ZZ2384+ZZ2384 -+006710 016200 ZZ2384=ZZ2384+ZZ2384 -+006710 034400 ZZ2384=ZZ2384+ZZ2384 -+006710 013415 0 8192 -ZZ1384 -+006711 034400 0 ZZ2384 -- mark 2327, 303 /38 gemi -+006712 001136 ZZ2385=ZZ2385+ZZ2385 -+006712 002274 ZZ2385=ZZ2385+ZZ2385 -+006712 004570 ZZ2385=ZZ2385+ZZ2385 -+006712 011360 ZZ2385=ZZ2385+ZZ2385 -+006712 022740 ZZ2385=ZZ2385+ZZ2385 -+006712 045700 ZZ2385=ZZ2385+ZZ2385 -+006712 113600 ZZ2385=ZZ2385+ZZ2385 -+006712 227400 ZZ2385=ZZ2385+ZZ2385 -+006712 013351 0 8192 -ZZ1385 -+006713 227400 0 ZZ2385 -- mark 2328, -457 /15 cmaj -+006714 776154 ZZ2386=ZZ2386+ZZ2386 -+006714 774330 ZZ2386=ZZ2386+ZZ2386 -+006714 770660 ZZ2386=ZZ2386+ZZ2386 -+006714 761540 ZZ2386=ZZ2386+ZZ2386 -+006714 743300 ZZ2386=ZZ2386+ZZ2386 -+006714 706600 ZZ2386=ZZ2386+ZZ2386 -+006714 615400 ZZ2386=ZZ2386+ZZ2386 -+006714 433000 ZZ2386=ZZ2386+ZZ2386 -+006714 013350 0 8192 -ZZ1386 -+006715 433000 0 ZZ2386 -- mark 2330, -271 /14 cmaj -+006716 776740 ZZ2387=ZZ2387+ZZ2387 -+006716 775700 ZZ2387=ZZ2387+ZZ2387 -+006716 773600 ZZ2387=ZZ2387+ZZ2387 -+006716 767400 ZZ2387=ZZ2387+ZZ2387 -+006716 757000 ZZ2387=ZZ2387+ZZ2387 -+006716 736000 ZZ2387=ZZ2387+ZZ2387 -+006716 674000 ZZ2387=ZZ2387+ZZ2387 -+006716 570000 ZZ2387=ZZ2387+ZZ2387 -+006716 013346 0 8192 -ZZ1387 -+006717 570000 0 ZZ2387 -- mark 2340, -456 /19 cmaj -+006720 776156 ZZ2388=ZZ2388+ZZ2388 -+006720 774334 ZZ2388=ZZ2388+ZZ2388 -+006720 770670 ZZ2388=ZZ2388+ZZ2388 -+006720 761560 ZZ2388=ZZ2388+ZZ2388 -+006720 743340 ZZ2388=ZZ2388+ZZ2388 -+006720 706700 ZZ2388=ZZ2388+ZZ2388 -+006720 615600 ZZ2388=ZZ2388+ZZ2388 -+006720 433400 ZZ2388=ZZ2388+ZZ2388 -+006720 013334 0 8192 -ZZ1388 -+006721 433400 0 ZZ2388 -- mark 2342, -385 /20 cmaj -+006722 776374 ZZ2389=ZZ2389+ZZ2389 -+006722 774770 ZZ2389=ZZ2389+ZZ2389 -+006722 771760 ZZ2389=ZZ2389+ZZ2389 -+006722 763740 ZZ2389=ZZ2389+ZZ2389 -+006722 747700 ZZ2389=ZZ2389+ZZ2389 -+006722 717600 ZZ2389=ZZ2389+ZZ2389 -+006722 637400 ZZ2389=ZZ2389+ZZ2389 -+006722 477000 ZZ2389=ZZ2389+ZZ2389 -+006722 013332 0 8192 -ZZ1389 -+006723 477000 0 ZZ2389 -- mark 2378, -93 /19 mono -+006724 777504 ZZ2390=ZZ2390+ZZ2390 -+006724 777210 ZZ2390=ZZ2390+ZZ2390 -+006724 776420 ZZ2390=ZZ2390+ZZ2390 -+006724 775040 ZZ2390=ZZ2390+ZZ2390 -+006724 772100 ZZ2390=ZZ2390+ZZ2390 -+006724 764200 ZZ2390=ZZ2390+ZZ2390 -+006724 750400 ZZ2390=ZZ2390+ZZ2390 -+006724 721000 ZZ2390=ZZ2390+ZZ2390 -+006724 013266 0 8192 -ZZ1390 -+006725 721000 0 ZZ2390 -- mark 2379, 471 /43 gemi -+006726 001656 ZZ2391=ZZ2391+ZZ2391 -+006726 003534 ZZ2391=ZZ2391+ZZ2391 -+006726 007270 ZZ2391=ZZ2391+ZZ2391 -+006726 016560 ZZ2391=ZZ2391+ZZ2391 -+006726 035340 ZZ2391=ZZ2391+ZZ2391 -+006726 072700 ZZ2391=ZZ2391+ZZ2391 -+006726 165600 ZZ2391=ZZ2391+ZZ2391 -+006726 353400 ZZ2391=ZZ2391+ZZ2391 -+006726 013265 0 8192 -ZZ1391 -+006727 353400 0 ZZ2391 -- mark 2385, -352 /23 cmaj -+006730 776476 ZZ2392=ZZ2392+ZZ2392 -+006730 775174 ZZ2392=ZZ2392+ZZ2392 -+006730 772370 ZZ2392=ZZ2392+ZZ2392 -+006730 764760 ZZ2392=ZZ2392+ZZ2392 -+006730 751740 ZZ2392=ZZ2392+ZZ2392 -+006730 723700 ZZ2392=ZZ2392+ZZ2392 -+006730 647600 ZZ2392=ZZ2392+ZZ2392 -+006730 517400 ZZ2392=ZZ2392+ZZ2392 -+006730 013257 0 8192 -ZZ1392 -+006731 517400 0 ZZ2392 -- mark 2428, -8 /22 mono -+006732 777756 ZZ2393=ZZ2393+ZZ2393 -+006732 777734 ZZ2393=ZZ2393+ZZ2393 -+006732 777670 ZZ2393=ZZ2393+ZZ2393 -+006732 777560 ZZ2393=ZZ2393+ZZ2393 -+006732 777340 ZZ2393=ZZ2393+ZZ2393 -+006732 776700 ZZ2393=ZZ2393+ZZ2393 -+006732 775600 ZZ2393=ZZ2393+ZZ2393 -+006732 773400 ZZ2393=ZZ2393+ZZ2393 -+006732 013204 0 8192 -ZZ1393 -+006733 773400 0 ZZ2393 -- mark 2491, -429 / -+006734 776244 ZZ2394=ZZ2394+ZZ2394 -+006734 774510 ZZ2394=ZZ2394+ZZ2394 -+006734 771220 ZZ2394=ZZ2394+ZZ2394 -+006734 762440 ZZ2394=ZZ2394+ZZ2394 -+006734 745100 ZZ2394=ZZ2394+ZZ2394 -+006734 712200 ZZ2394=ZZ2394+ZZ2394 -+006734 624400 ZZ2394=ZZ2394+ZZ2394 -+006734 451000 ZZ2394=ZZ2394+ZZ2394 -+006734 013105 0 8192 -ZZ1394 -+006735 451000 0 ZZ2394 -- mark 2519, 208 / 4 cmin -+006736 000640 ZZ2395=ZZ2395+ZZ2395 -+006736 001500 ZZ2395=ZZ2395+ZZ2395 -+006736 003200 ZZ2395=ZZ2395+ZZ2395 -+006736 006400 ZZ2395=ZZ2395+ZZ2395 -+006736 015000 ZZ2395=ZZ2395+ZZ2395 -+006736 032000 ZZ2395=ZZ2395+ZZ2395 -+006736 064000 ZZ2395=ZZ2395+ZZ2395 -+006736 150000 ZZ2395=ZZ2395+ZZ2395 -+006736 013051 0 8192 -ZZ1395 -+006737 150000 0 ZZ2395 -- mark 2527, 278 / 6 cmin -+006740 001054 ZZ2396=ZZ2396+ZZ2396 -+006740 002130 ZZ2396=ZZ2396+ZZ2396 -+006740 004260 ZZ2396=ZZ2396+ZZ2396 -+006740 010540 ZZ2396=ZZ2396+ZZ2396 -+006740 021300 ZZ2396=ZZ2396+ZZ2396 -+006740 042600 ZZ2396=ZZ2396+ZZ2396 -+006740 105400 ZZ2396=ZZ2396+ZZ2396 -+006740 213000 ZZ2396=ZZ2396+ZZ2396 -+006740 013041 0 8192 -ZZ1396 -+006741 213000 0 ZZ2396 -- mark 2559, -503 / -+006742 776020 ZZ2397=ZZ2397+ZZ2397 -+006742 774040 ZZ2397=ZZ2397+ZZ2397 -+006742 770100 ZZ2397=ZZ2397+ZZ2397 -+006742 760200 ZZ2397=ZZ2397+ZZ2397 -+006742 740400 ZZ2397=ZZ2397+ZZ2397 -+006742 701000 ZZ2397=ZZ2397+ZZ2397 -+006742 602000 ZZ2397=ZZ2397+ZZ2397 -+006742 404000 ZZ2397=ZZ2397+ZZ2397 -+006742 013001 0 8192 -ZZ1397 -+006743 404000 0 ZZ2397 -- mark 2597, -212 /26 mono -+006744 777126 ZZ2398=ZZ2398+ZZ2398 -+006744 776254 ZZ2398=ZZ2398+ZZ2398 -+006744 774530 ZZ2398=ZZ2398+ZZ2398 -+006744 771260 ZZ2398=ZZ2398+ZZ2398 -+006744 762540 ZZ2398=ZZ2398+ZZ2398 -+006744 745300 ZZ2398=ZZ2398+ZZ2398 -+006744 712600 ZZ2398=ZZ2398+ZZ2398 -+006744 625400 ZZ2398=ZZ2398+ZZ2398 -+006744 012733 0 8192 -ZZ1398 -+006745 625400 0 ZZ2398 -- mark 2704, -412 / -+006746 776306 ZZ2399=ZZ2399+ZZ2399 -+006746 774614 ZZ2399=ZZ2399+ZZ2399 -+006746 771430 ZZ2399=ZZ2399+ZZ2399 -+006746 763060 ZZ2399=ZZ2399+ZZ2399 -+006746 746140 ZZ2399=ZZ2399+ZZ2399 -+006746 714300 ZZ2399=ZZ2399+ZZ2399 -+006746 630600 ZZ2399=ZZ2399+ZZ2399 -+006746 461400 ZZ2399=ZZ2399+ZZ2399 -+006746 012560 0 8192 -ZZ1399 -+006747 461400 0 ZZ2399 -- mark 2709, -25 /28 mono -+006750 777714 ZZ2400=ZZ2400+ZZ2400 -+006750 777630 ZZ2400=ZZ2400+ZZ2400 -+006750 777460 ZZ2400=ZZ2400+ZZ2400 -+006750 777140 ZZ2400=ZZ2400+ZZ2400 -+006750 776300 ZZ2400=ZZ2400+ZZ2400 -+006750 774600 ZZ2400=ZZ2400+ZZ2400 -+006750 771400 ZZ2400=ZZ2400+ZZ2400 -+006750 763000 ZZ2400=ZZ2400+ZZ2400 -+006750 012553 0 8192 -ZZ1400 -+006751 763000 0 ZZ2400 -- mark 2714, 60 / -+006752 000170 ZZ2401=ZZ2401+ZZ2401 -+006752 000360 ZZ2401=ZZ2401+ZZ2401 -+006752 000740 ZZ2401=ZZ2401+ZZ2401 -+006752 001700 ZZ2401=ZZ2401+ZZ2401 -+006752 003600 ZZ2401=ZZ2401+ZZ2401 -+006752 007400 ZZ2401=ZZ2401+ZZ2401 -+006752 017000 ZZ2401=ZZ2401+ZZ2401 -+006752 036000 ZZ2401=ZZ2401+ZZ2401 -+006752 012546 0 8192 -ZZ1401 -+006753 036000 0 ZZ2401 -- mark 2751, -61 /29 mono -+006754 777604 ZZ2402=ZZ2402+ZZ2402 -+006754 777410 ZZ2402=ZZ2402+ZZ2402 -+006754 777020 ZZ2402=ZZ2402+ZZ2402 -+006754 776040 ZZ2402=ZZ2402+ZZ2402 -+006754 774100 ZZ2402=ZZ2402+ZZ2402 -+006754 770200 ZZ2402=ZZ2402+ZZ2402 -+006754 760400 ZZ2402=ZZ2402+ZZ2402 -+006754 741000 ZZ2402=ZZ2402+ZZ2402 -+006754 012501 0 8192 -ZZ1402 -+006755 741000 0 ZZ2402 -- mark 2757, -431 /16 pupp -+006756 776240 ZZ2403=ZZ2403+ZZ2403 -+006756 774500 ZZ2403=ZZ2403+ZZ2403 -+006756 771200 ZZ2403=ZZ2403+ZZ2403 -+006756 762400 ZZ2403=ZZ2403+ZZ2403 -+006756 745000 ZZ2403=ZZ2403+ZZ2403 -+006756 712000 ZZ2403=ZZ2403+ZZ2403 -+006756 624000 ZZ2403=ZZ2403+ZZ2403 -+006756 450000 ZZ2403=ZZ2403+ZZ2403 -+006756 012473 0 8192 -ZZ1403 -+006757 450000 0 ZZ2403 -- mark 2768, -288 /19 pupp -+006760 776676 ZZ2404=ZZ2404+ZZ2404 -+006760 775574 ZZ2404=ZZ2404+ZZ2404 -+006760 773370 ZZ2404=ZZ2404+ZZ2404 -+006760 766760 ZZ2404=ZZ2404+ZZ2404 -+006760 755740 ZZ2404=ZZ2404+ZZ2404 -+006760 733700 ZZ2404=ZZ2404+ZZ2404 -+006760 667600 ZZ2404=ZZ2404+ZZ2404 -+006760 557400 ZZ2404=ZZ2404+ZZ2404 -+006760 012460 0 8192 -ZZ1404 -+006761 557400 0 ZZ2404 -- mark 2794, 216 /17 canc -+006762 000660 ZZ2405=ZZ2405+ZZ2405 -+006762 001540 ZZ2405=ZZ2405+ZZ2405 -+006762 003300 ZZ2405=ZZ2405+ZZ2405 -+006762 006600 ZZ2405=ZZ2405+ZZ2405 -+006762 015400 ZZ2405=ZZ2405+ZZ2405 -+006762 033000 ZZ2405=ZZ2405+ZZ2405 -+006762 066000 ZZ2405=ZZ2405+ZZ2405 -+006762 154000 ZZ2405=ZZ2405+ZZ2405 -+006762 012426 0 8192 -ZZ1405 -+006763 154000 0 ZZ2405 -- mark 2848, -82 / -+006764 777532 ZZ2406=ZZ2406+ZZ2406 -+006764 777264 ZZ2406=ZZ2406+ZZ2406 -+006764 776550 ZZ2406=ZZ2406+ZZ2406 -+006764 775320 ZZ2406=ZZ2406+ZZ2406 -+006764 772640 ZZ2406=ZZ2406+ZZ2406 -+006764 765500 ZZ2406=ZZ2406+ZZ2406 -+006764 753200 ZZ2406=ZZ2406+ZZ2406 -+006764 726400 ZZ2406=ZZ2406+ZZ2406 -+006764 012340 0 8192 -ZZ1406 -+006765 726400 0 ZZ2406 -- mark 2915, 138 / 4 hyda -+006766 000424 ZZ2407=ZZ2407+ZZ2407 -+006766 001050 ZZ2407=ZZ2407+ZZ2407 -+006766 002120 ZZ2407=ZZ2407+ZZ2407 -+006766 004240 ZZ2407=ZZ2407+ZZ2407 -+006766 010500 ZZ2407=ZZ2407+ZZ2407 -+006766 021200 ZZ2407=ZZ2407+ZZ2407 -+006766 042400 ZZ2407=ZZ2407+ZZ2407 -+006766 105000 ZZ2407=ZZ2407+ZZ2407 -+006766 012235 0 8192 -ZZ1407 -+006767 105000 0 ZZ2407 -- mark 2921, 84 / 5 hyda -+006770 000250 ZZ2408=ZZ2408+ZZ2408 -+006770 000520 ZZ2408=ZZ2408+ZZ2408 -+006770 001240 ZZ2408=ZZ2408+ZZ2408 -+006770 002500 ZZ2408=ZZ2408+ZZ2408 -+006770 005200 ZZ2408=ZZ2408+ZZ2408 -+006770 012400 ZZ2408=ZZ2408+ZZ2408 -+006770 025000 ZZ2408=ZZ2408+ZZ2408 -+006770 052000 ZZ2408=ZZ2408+ZZ2408 -+006770 012227 0 8192 -ZZ1408 -+006771 052000 0 ZZ2408 -- mark 2942, -355 / 9 hyda -+006772 776470 ZZ2409=ZZ2409+ZZ2409 -+006772 775160 ZZ2409=ZZ2409+ZZ2409 -+006772 772340 ZZ2409=ZZ2409+ZZ2409 -+006772 764700 ZZ2409=ZZ2409+ZZ2409 -+006772 751600 ZZ2409=ZZ2409+ZZ2409 -+006772 723400 ZZ2409=ZZ2409+ZZ2409 -+006772 647000 ZZ2409=ZZ2409+ZZ2409 -+006772 516000 ZZ2409=ZZ2409+ZZ2409 -+006772 012202 0 8192 -ZZ1409 -+006773 516000 0 ZZ2409 -- mark 2944, 497 /43 canc -+006774 001742 ZZ2410=ZZ2410+ZZ2410 -+006774 003704 ZZ2410=ZZ2410+ZZ2410 -+006774 007610 ZZ2410=ZZ2410+ZZ2410 -+006774 017420 ZZ2410=ZZ2410+ZZ2410 -+006774 037040 ZZ2410=ZZ2410+ZZ2410 -+006774 076100 ZZ2410=ZZ2410+ZZ2410 -+006774 174200 ZZ2410=ZZ2410+ZZ2410 -+006774 370400 ZZ2410=ZZ2410+ZZ2410 -+006774 012200 0 8192 -ZZ1410 -+006775 370400 0 ZZ2410 -- mark 2947, 85 / 7 hyda -+006776 000252 ZZ2411=ZZ2411+ZZ2411 -+006776 000524 ZZ2411=ZZ2411+ZZ2411 -+006776 001250 ZZ2411=ZZ2411+ZZ2411 -+006776 002520 ZZ2411=ZZ2411+ZZ2411 -+006776 005240 ZZ2411=ZZ2411+ZZ2411 -+006776 012500 ZZ2411=ZZ2411+ZZ2411 -+006776 025200 ZZ2411=ZZ2411+ZZ2411 -+006776 052400 ZZ2411=ZZ2411+ZZ2411 -+006776 012175 0 8192 -ZZ1411 -+006777 052400 0 ZZ2411 -- mark 2951, -156 / -+007000 777306 ZZ2412=ZZ2412+ZZ2412 -+007000 776614 ZZ2412=ZZ2412+ZZ2412 -+007000 775430 ZZ2412=ZZ2412+ZZ2412 -+007000 773060 ZZ2412=ZZ2412+ZZ2412 -+007000 766140 ZZ2412=ZZ2412+ZZ2412 -+007000 754300 ZZ2412=ZZ2412+ZZ2412 -+007000 730600 ZZ2412=ZZ2412+ZZ2412 -+007000 661400 ZZ2412=ZZ2412+ZZ2412 -+007000 012171 0 8192 -ZZ1412 -+007001 661400 0 ZZ2412 -- mark 2953, 421 /47 canc -+007002 001512 ZZ2413=ZZ2413+ZZ2413 -+007002 003224 ZZ2413=ZZ2413+ZZ2413 -+007002 006450 ZZ2413=ZZ2413+ZZ2413 -+007002 015120 ZZ2413=ZZ2413+ZZ2413 -+007002 032240 ZZ2413=ZZ2413+ZZ2413 -+007002 064500 ZZ2413=ZZ2413+ZZ2413 -+007002 151200 ZZ2413=ZZ2413+ZZ2413 -+007002 322400 ZZ2413=ZZ2413+ZZ2413 -+007002 012167 0 8192 -ZZ1413 -+007003 322400 0 ZZ2413 -- mark 2968, -300 /12 hyda -+007004 776646 ZZ2414=ZZ2414+ZZ2414 -+007004 775514 ZZ2414=ZZ2414+ZZ2414 -+007004 773230 ZZ2414=ZZ2414+ZZ2414 -+007004 766460 ZZ2414=ZZ2414+ZZ2414 -+007004 755140 ZZ2414=ZZ2414+ZZ2414 -+007004 732300 ZZ2414=ZZ2414+ZZ2414 -+007004 664600 ZZ2414=ZZ2414+ZZ2414 -+007004 551400 ZZ2414=ZZ2414+ZZ2414 -+007004 012150 0 8192 -ZZ1414 -+007005 551400 0 ZZ2414 -- mark 2976, 141 /13 hyda -+007006 000432 ZZ2415=ZZ2415+ZZ2415 -+007006 001064 ZZ2415=ZZ2415+ZZ2415 -+007006 002150 ZZ2415=ZZ2415+ZZ2415 -+007006 004320 ZZ2415=ZZ2415+ZZ2415 -+007006 010640 ZZ2415=ZZ2415+ZZ2415 -+007006 021500 ZZ2415=ZZ2415+ZZ2415 -+007006 043200 ZZ2415=ZZ2415+ZZ2415 -+007006 106400 ZZ2415=ZZ2415+ZZ2415 -+007006 012140 0 8192 -ZZ1415 -+007007 106400 0 ZZ2415 -- mark 3032, 279 /65 canc -+007010 001056 ZZ2416=ZZ2416+ZZ2416 -+007010 002134 ZZ2416=ZZ2416+ZZ2416 -+007010 004270 ZZ2416=ZZ2416+ZZ2416 -+007010 010560 ZZ2416=ZZ2416+ZZ2416 -+007010 021340 ZZ2416=ZZ2416+ZZ2416 -+007010 042700 ZZ2416=ZZ2416+ZZ2416 -+007010 105600 ZZ2416=ZZ2416+ZZ2416 -+007010 213400 ZZ2416=ZZ2416+ZZ2416 -+007010 012050 0 8192 -ZZ1416 -+007011 213400 0 ZZ2416 -- mark 3124, 62 /22 hyda -+007012 000174 ZZ2417=ZZ2417+ZZ2417 -+007012 000370 ZZ2417=ZZ2417+ZZ2417 -+007012 000760 ZZ2417=ZZ2417+ZZ2417 -+007012 001740 ZZ2417=ZZ2417+ZZ2417 -+007012 003700 ZZ2417=ZZ2417+ZZ2417 -+007012 007600 ZZ2417=ZZ2417+ZZ2417 -+007012 017400 ZZ2417=ZZ2417+ZZ2417 -+007012 037000 ZZ2417=ZZ2417+ZZ2417 -+007012 011714 0 8192 -ZZ1417 -+007013 037000 0 ZZ2417 -- mark 3157, -263 /26 hyda -+007014 776760 ZZ2418=ZZ2418+ZZ2418 -+007014 775740 ZZ2418=ZZ2418+ZZ2418 -+007014 773700 ZZ2418=ZZ2418+ZZ2418 -+007014 767600 ZZ2418=ZZ2418+ZZ2418 -+007014 757400 ZZ2418=ZZ2418+ZZ2418 -+007014 737000 ZZ2418=ZZ2418+ZZ2418 -+007014 676000 ZZ2418=ZZ2418+ZZ2418 -+007014 574000 ZZ2418=ZZ2418+ZZ2418 -+007014 011653 0 8192 -ZZ1418 -+007015 574000 0 ZZ2418 -- mark 3161, -208 /27 hyda -+007016 777136 ZZ2419=ZZ2419+ZZ2419 -+007016 776274 ZZ2419=ZZ2419+ZZ2419 -+007016 774570 ZZ2419=ZZ2419+ZZ2419 -+007016 771360 ZZ2419=ZZ2419+ZZ2419 -+007016 762740 ZZ2419=ZZ2419+ZZ2419 -+007016 745700 ZZ2419=ZZ2419+ZZ2419 -+007016 713600 ZZ2419=ZZ2419+ZZ2419 -+007016 627400 ZZ2419=ZZ2419+ZZ2419 -+007016 011647 0 8192 -ZZ1419 -+007017 627400 0 ZZ2419 -- mark 3209, -53 /31 hyda -+007020 777624 ZZ2420=ZZ2420+ZZ2420 -+007020 777450 ZZ2420=ZZ2420+ZZ2420 -+007020 777120 ZZ2420=ZZ2420+ZZ2420 -+007020 776240 ZZ2420=ZZ2420+ZZ2420 -+007020 774500 ZZ2420=ZZ2420+ZZ2420 -+007020 771200 ZZ2420=ZZ2420+ZZ2420 -+007020 762400 ZZ2420=ZZ2420+ZZ2420 -+007020 745000 ZZ2420=ZZ2420+ZZ2420 -+007020 011567 0 8192 -ZZ1420 -+007021 745000 0 ZZ2420 -- mark 3225, -17 /32 hyda -+007022 777734 ZZ2421=ZZ2421+ZZ2421 -+007022 777670 ZZ2421=ZZ2421+ZZ2421 -+007022 777560 ZZ2421=ZZ2421+ZZ2421 -+007022 777340 ZZ2421=ZZ2421+ZZ2421 -+007022 776700 ZZ2421=ZZ2421+ZZ2421 -+007022 775600 ZZ2421=ZZ2421+ZZ2421 -+007022 773400 ZZ2421=ZZ2421+ZZ2421 -+007022 767000 ZZ2421=ZZ2421+ZZ2421 -+007022 011547 0 8192 -ZZ1421 -+007023 767000 0 ZZ2421 -- mark 3261, 116 / -+007024 000350 ZZ2422=ZZ2422+ZZ2422 -+007024 000720 ZZ2422=ZZ2422+ZZ2422 -+007024 001640 ZZ2422=ZZ2422+ZZ2422 -+007024 003500 ZZ2422=ZZ2422+ZZ2422 -+007024 007200 ZZ2422=ZZ2422+ZZ2422 -+007024 016400 ZZ2422=ZZ2422+ZZ2422 -+007024 035000 ZZ2422=ZZ2422+ZZ2422 -+007024 072000 ZZ2422=ZZ2422+ZZ2422 -+007024 011503 0 8192 -ZZ1422 -+007025 072000 0 ZZ2422 -- mark 3270, -16 /35 hyda -+007026 777736 ZZ2423=ZZ2423+ZZ2423 -+007026 777674 ZZ2423=ZZ2423+ZZ2423 -+007026 777570 ZZ2423=ZZ2423+ZZ2423 -+007026 777360 ZZ2423=ZZ2423+ZZ2423 -+007026 776740 ZZ2423=ZZ2423+ZZ2423 -+007026 775700 ZZ2423=ZZ2423+ZZ2423 -+007026 773600 ZZ2423=ZZ2423+ZZ2423 -+007026 767400 ZZ2423=ZZ2423+ZZ2423 -+007026 011472 0 8192 -ZZ1423 -+007027 767400 0 ZZ2423 -- mark 3274, -316 /38 hyda -+007030 776606 ZZ2424=ZZ2424+ZZ2424 -+007030 775414 ZZ2424=ZZ2424+ZZ2424 -+007030 773030 ZZ2424=ZZ2424+ZZ2424 -+007030 766060 ZZ2424=ZZ2424+ZZ2424 -+007030 754140 ZZ2424=ZZ2424+ZZ2424 -+007030 730300 ZZ2424=ZZ2424+ZZ2424 -+007030 660600 ZZ2424=ZZ2424+ZZ2424 -+007030 541400 ZZ2424=ZZ2424+ZZ2424 -+007030 011466 0 8192 -ZZ1424 -+007031 541400 0 ZZ2424 -- mark 3276, 236 /14 leon -+007032 000730 ZZ2425=ZZ2425+ZZ2425 -+007032 001660 ZZ2425=ZZ2425+ZZ2425 -+007032 003540 ZZ2425=ZZ2425+ZZ2425 -+007032 007300 ZZ2425=ZZ2425+ZZ2425 -+007032 016600 ZZ2425=ZZ2425+ZZ2425 -+007032 035400 ZZ2425=ZZ2425+ZZ2425 -+007032 073000 ZZ2425=ZZ2425+ZZ2425 -+007032 166000 ZZ2425=ZZ2425+ZZ2425 -+007032 011464 0 8192 -ZZ1425 -+007033 166000 0 ZZ2425 -- mark 3338, -327 /39 hyda -+007034 776560 ZZ2426=ZZ2426+ZZ2426 -+007034 775340 ZZ2426=ZZ2426+ZZ2426 -+007034 772700 ZZ2426=ZZ2426+ZZ2426 -+007034 765600 ZZ2426=ZZ2426+ZZ2426 -+007034 753400 ZZ2426=ZZ2426+ZZ2426 -+007034 727000 ZZ2426=ZZ2426+ZZ2426 -+007034 656000 ZZ2426=ZZ2426+ZZ2426 -+007034 534000 ZZ2426=ZZ2426+ZZ2426 -+007034 011366 0 8192 -ZZ1426 -+007035 534000 0 ZZ2426 -- mark 3385, 194 /29 leon -+007036 000604 ZZ2427=ZZ2427+ZZ2427 -+007036 001410 ZZ2427=ZZ2427+ZZ2427 -+007036 003020 ZZ2427=ZZ2427+ZZ2427 -+007036 006040 ZZ2427=ZZ2427+ZZ2427 -+007036 014100 ZZ2427=ZZ2427+ZZ2427 -+007036 030200 ZZ2427=ZZ2427+ZZ2427 -+007036 060400 ZZ2427=ZZ2427+ZZ2427 -+007036 141000 ZZ2427=ZZ2427+ZZ2427 -+007036 011307 0 8192 -ZZ1427 -+007037 141000 0 ZZ2427 -- mark 3415, -286 /40 hyda -+007040 776702 ZZ2428=ZZ2428+ZZ2428 -+007040 775604 ZZ2428=ZZ2428+ZZ2428 -+007040 773410 ZZ2428=ZZ2428+ZZ2428 -+007040 767020 ZZ2428=ZZ2428+ZZ2428 -+007040 756040 ZZ2428=ZZ2428+ZZ2428 -+007040 734100 ZZ2428=ZZ2428+ZZ2428 -+007040 670200 ZZ2428=ZZ2428+ZZ2428 -+007040 560400 ZZ2428=ZZ2428+ZZ2428 -+007040 011251 0 8192 -ZZ1428 -+007041 560400 0 ZZ2428 -- mark 3428, 239 /31 leon -+007042 000736 ZZ2429=ZZ2429+ZZ2429 -+007042 001674 ZZ2429=ZZ2429+ZZ2429 -+007042 003570 ZZ2429=ZZ2429+ZZ2429 -+007042 007360 ZZ2429=ZZ2429+ZZ2429 -+007042 016740 ZZ2429=ZZ2429+ZZ2429 -+007042 035700 ZZ2429=ZZ2429+ZZ2429 -+007042 073600 ZZ2429=ZZ2429+ZZ2429 -+007042 167400 ZZ2429=ZZ2429+ZZ2429 -+007042 011234 0 8192 -ZZ1429 -+007043 167400 0 ZZ2429 -- mark 3429, 3 /15 sext -+007044 000006 ZZ2430=ZZ2430+ZZ2430 -+007044 000014 ZZ2430=ZZ2430+ZZ2430 -+007044 000030 ZZ2430=ZZ2430+ZZ2430 -+007044 000060 ZZ2430=ZZ2430+ZZ2430 -+007044 000140 ZZ2430=ZZ2430+ZZ2430 -+007044 000300 ZZ2430=ZZ2430+ZZ2430 -+007044 000600 ZZ2430=ZZ2430+ZZ2430 -+007044 001400 ZZ2430=ZZ2430+ZZ2430 -+007044 011233 0 8192 -ZZ1430 -+007045 001400 0 ZZ2430 -- mark 3446, -270 /41 hyda -+007046 776742 ZZ2431=ZZ2431+ZZ2431 -+007046 775704 ZZ2431=ZZ2431+ZZ2431 -+007046 773610 ZZ2431=ZZ2431+ZZ2431 -+007046 767420 ZZ2431=ZZ2431+ZZ2431 -+007046 757040 ZZ2431=ZZ2431+ZZ2431 -+007046 736100 ZZ2431=ZZ2431+ZZ2431 -+007046 674200 ZZ2431=ZZ2431+ZZ2431 -+007046 570400 ZZ2431=ZZ2431+ZZ2431 -+007046 011212 0 8192 -ZZ1431 -+007047 570400 0 ZZ2431 -- mark 3495, 455 /40 leon -+007050 001616 ZZ2432=ZZ2432+ZZ2432 -+007050 003434 ZZ2432=ZZ2432+ZZ2432 -+007050 007070 ZZ2432=ZZ2432+ZZ2432 -+007050 016160 ZZ2432=ZZ2432+ZZ2432 -+007050 034340 ZZ2432=ZZ2432+ZZ2432 -+007050 070700 ZZ2432=ZZ2432+ZZ2432 -+007050 161600 ZZ2432=ZZ2432+ZZ2432 -+007050 343400 ZZ2432=ZZ2432+ZZ2432 -+007050 011131 0 8192 -ZZ1432 -+007051 343400 0 ZZ2432 -- mark 3534, -372 /42 hyda -+007052 776426 ZZ2433=ZZ2433+ZZ2433 -+007052 775054 ZZ2433=ZZ2433+ZZ2433 -+007052 772130 ZZ2433=ZZ2433+ZZ2433 -+007052 764260 ZZ2433=ZZ2433+ZZ2433 -+007052 750540 ZZ2433=ZZ2433+ZZ2433 -+007052 721300 ZZ2433=ZZ2433+ZZ2433 -+007052 642600 ZZ2433=ZZ2433+ZZ2433 -+007052 505400 ZZ2433=ZZ2433+ZZ2433 -+007052 011062 0 8192 -ZZ1433 -+007053 505400 0 ZZ2433 -- mark 3557, -3 /30 sext -+007054 777770 ZZ2434=ZZ2434+ZZ2434 -+007054 777760 ZZ2434=ZZ2434+ZZ2434 -+007054 777740 ZZ2434=ZZ2434+ZZ2434 -+007054 777700 ZZ2434=ZZ2434+ZZ2434 -+007054 777600 ZZ2434=ZZ2434+ZZ2434 -+007054 777400 ZZ2434=ZZ2434+ZZ2434 -+007054 777000 ZZ2434=ZZ2434+ZZ2434 -+007054 776000 ZZ2434=ZZ2434+ZZ2434 -+007054 011033 0 8192 -ZZ1434 -+007055 776000 0 ZZ2434 -- mark 3570, 223 /47 leon -+007056 000676 ZZ2435=ZZ2435+ZZ2435 -+007056 001574 ZZ2435=ZZ2435+ZZ2435 -+007056 003370 ZZ2435=ZZ2435+ZZ2435 -+007056 006760 ZZ2435=ZZ2435+ZZ2435 -+007056 015740 ZZ2435=ZZ2435+ZZ2435 -+007056 033700 ZZ2435=ZZ2435+ZZ2435 -+007056 067600 ZZ2435=ZZ2435+ZZ2435 -+007056 157400 ZZ2435=ZZ2435+ZZ2435 -+007056 011016 0 8192 -ZZ1435 -+007057 157400 0 ZZ2435 -- mark 3726, -404 /al crat -+007060 776326 ZZ2436=ZZ2436+ZZ2436 -+007060 774654 ZZ2436=ZZ2436+ZZ2436 -+007060 771530 ZZ2436=ZZ2436+ZZ2436 -+007060 763260 ZZ2436=ZZ2436+ZZ2436 -+007060 746540 ZZ2436=ZZ2436+ZZ2436 -+007060 715300 ZZ2436=ZZ2436+ZZ2436 -+007060 632600 ZZ2436=ZZ2436+ZZ2436 -+007060 465400 ZZ2436=ZZ2436+ZZ2436 -+007060 010562 0 8192 -ZZ1436 -+007061 465400 0 ZZ2436 -- mark 3736, -44 /61 leon -+007062 777646 ZZ2437=ZZ2437+ZZ2437 -+007062 777514 ZZ2437=ZZ2437+ZZ2437 -+007062 777230 ZZ2437=ZZ2437+ZZ2437 -+007062 776460 ZZ2437=ZZ2437+ZZ2437 -+007062 775140 ZZ2437=ZZ2437+ZZ2437 -+007062 772300 ZZ2437=ZZ2437+ZZ2437 -+007062 764600 ZZ2437=ZZ2437+ZZ2437 -+007062 751400 ZZ2437=ZZ2437+ZZ2437 -+007062 010550 0 8192 -ZZ1437 -+007063 751400 0 ZZ2437 -- mark 3738, 471 /60 leon -+007064 001656 ZZ2438=ZZ2438+ZZ2438 -+007064 003534 ZZ2438=ZZ2438+ZZ2438 -+007064 007270 ZZ2438=ZZ2438+ZZ2438 -+007064 016560 ZZ2438=ZZ2438+ZZ2438 -+007064 035340 ZZ2438=ZZ2438+ZZ2438 -+007064 072700 ZZ2438=ZZ2438+ZZ2438 -+007064 165600 ZZ2438=ZZ2438+ZZ2438 -+007064 353400 ZZ2438=ZZ2438+ZZ2438 -+007064 010546 0 8192 -ZZ1438 -+007065 353400 0 ZZ2438 -- mark 3754, 179 /63 leon -+007066 000546 ZZ2439=ZZ2439+ZZ2439 -+007066 001314 ZZ2439=ZZ2439+ZZ2439 -+007066 002630 ZZ2439=ZZ2439+ZZ2439 -+007066 005460 ZZ2439=ZZ2439+ZZ2439 -+007066 013140 ZZ2439=ZZ2439+ZZ2439 -+007066 026300 ZZ2439=ZZ2439+ZZ2439 -+007066 054600 ZZ2439=ZZ2439+ZZ2439 -+007066 131400 ZZ2439=ZZ2439+ZZ2439 -+007066 010526 0 8192 -ZZ1439 -+007067 131400 0 ZZ2439 -- mark 3793, -507 /11 crat -+007070 776010 ZZ2440=ZZ2440+ZZ2440 -+007070 774020 ZZ2440=ZZ2440+ZZ2440 -+007070 770040 ZZ2440=ZZ2440+ZZ2440 -+007070 760100 ZZ2440=ZZ2440+ZZ2440 -+007070 740200 ZZ2440=ZZ2440+ZZ2440 -+007070 700400 ZZ2440=ZZ2440+ZZ2440 -+007070 601000 ZZ2440=ZZ2440+ZZ2440 -+007070 402000 ZZ2440=ZZ2440+ZZ2440 -+007070 010457 0 8192 -ZZ1440 -+007071 402000 0 ZZ2440 -- mark 3821, -71 /74 leon -+007072 777560 ZZ2441=ZZ2441+ZZ2441 -+007072 777340 ZZ2441=ZZ2441+ZZ2441 -+007072 776700 ZZ2441=ZZ2441+ZZ2441 -+007072 775600 ZZ2441=ZZ2441+ZZ2441 -+007072 773400 ZZ2441=ZZ2441+ZZ2441 -+007072 767000 ZZ2441=ZZ2441+ZZ2441 -+007072 756000 ZZ2441=ZZ2441+ZZ2441 -+007072 734000 ZZ2441=ZZ2441+ZZ2441 -+007072 010423 0 8192 -ZZ1441 -+007073 734000 0 ZZ2441 -- mark 3836, -324 /12 crat -+007074 776566 ZZ2442=ZZ2442+ZZ2442 -+007074 775354 ZZ2442=ZZ2442+ZZ2442 -+007074 772730 ZZ2442=ZZ2442+ZZ2442 -+007074 765660 ZZ2442=ZZ2442+ZZ2442 -+007074 753540 ZZ2442=ZZ2442+ZZ2442 -+007074 727300 ZZ2442=ZZ2442+ZZ2442 -+007074 656600 ZZ2442=ZZ2442+ZZ2442 -+007074 535400 ZZ2442=ZZ2442+ZZ2442 -+007074 010404 0 8192 -ZZ1442 -+007075 535400 0 ZZ2442 -- mark 3846, 150 /77 leon -+007076 000454 ZZ2443=ZZ2443+ZZ2443 -+007076 001130 ZZ2443=ZZ2443+ZZ2443 -+007076 002260 ZZ2443=ZZ2443+ZZ2443 -+007076 004540 ZZ2443=ZZ2443+ZZ2443 -+007076 011300 ZZ2443=ZZ2443+ZZ2443 -+007076 022600 ZZ2443=ZZ2443+ZZ2443 -+007076 045400 ZZ2443=ZZ2443+ZZ2443 -+007076 113000 ZZ2443=ZZ2443+ZZ2443 -+007076 010372 0 8192 -ZZ1443 -+007077 113000 0 ZZ2443 -- mark 3861, 252 /78 leon -+007100 000770 ZZ2444=ZZ2444+ZZ2444 -+007100 001760 ZZ2444=ZZ2444+ZZ2444 -+007100 003740 ZZ2444=ZZ2444+ZZ2444 -+007100 007700 ZZ2444=ZZ2444+ZZ2444 -+007100 017600 ZZ2444=ZZ2444+ZZ2444 -+007100 037400 ZZ2444=ZZ2444+ZZ2444 -+007100 077000 ZZ2444=ZZ2444+ZZ2444 -+007100 176000 ZZ2444=ZZ2444+ZZ2444 -+007100 010353 0 8192 -ZZ1444 -+007101 176000 0 ZZ2444 -- mark 3868, -390 /15 crat -+007102 776362 ZZ2445=ZZ2445+ZZ2445 -+007102 774744 ZZ2445=ZZ2445+ZZ2445 -+007102 771710 ZZ2445=ZZ2445+ZZ2445 -+007102 763620 ZZ2445=ZZ2445+ZZ2445 -+007102 747440 ZZ2445=ZZ2445+ZZ2445 -+007102 717100 ZZ2445=ZZ2445+ZZ2445 -+007102 636200 ZZ2445=ZZ2445+ZZ2445 -+007102 474400 ZZ2445=ZZ2445+ZZ2445 -+007102 010344 0 8192 -ZZ1445 -+007103 474400 0 ZZ2445 -- mark 3935, -211 /21 crat -+007104 777130 ZZ2446=ZZ2446+ZZ2446 -+007104 776260 ZZ2446=ZZ2446+ZZ2446 -+007104 774540 ZZ2446=ZZ2446+ZZ2446 -+007104 771300 ZZ2446=ZZ2446+ZZ2446 -+007104 762600 ZZ2446=ZZ2446+ZZ2446 -+007104 745400 ZZ2446=ZZ2446+ZZ2446 -+007104 713000 ZZ2446=ZZ2446+ZZ2446 -+007104 626000 ZZ2446=ZZ2446+ZZ2446 -+007104 010241 0 8192 -ZZ1446 -+007105 626000 0 ZZ2446 -- mark 3936, -6 /91 leon -+007106 777762 ZZ2447=ZZ2447+ZZ2447 -+007106 777744 ZZ2447=ZZ2447+ZZ2447 -+007106 777710 ZZ2447=ZZ2447+ZZ2447 -+007106 777620 ZZ2447=ZZ2447+ZZ2447 -+007106 777440 ZZ2447=ZZ2447+ZZ2447 -+007106 777100 ZZ2447=ZZ2447+ZZ2447 -+007106 776200 ZZ2447=ZZ2447+ZZ2447 -+007106 774400 ZZ2447=ZZ2447+ZZ2447 -+007106 010240 0 8192 -ZZ1447 -+007107 774400 0 ZZ2447 -- mark 3981, -405 /27 crat -+007110 776324 ZZ2448=ZZ2448+ZZ2448 -+007110 774650 ZZ2448=ZZ2448+ZZ2448 -+007110 771520 ZZ2448=ZZ2448+ZZ2448 -+007110 763240 ZZ2448=ZZ2448+ZZ2448 -+007110 746500 ZZ2448=ZZ2448+ZZ2448 -+007110 715200 ZZ2448=ZZ2448+ZZ2448 -+007110 632400 ZZ2448=ZZ2448+ZZ2448 -+007110 465000 ZZ2448=ZZ2448+ZZ2448 -+007110 010163 0 8192 -ZZ1448 -+007111 465000 0 ZZ2448 -- mark 3986, 161 / 3 virg -+007112 000502 ZZ2449=ZZ2449+ZZ2449 -+007112 001204 ZZ2449=ZZ2449+ZZ2449 -+007112 002410 ZZ2449=ZZ2449+ZZ2449 -+007112 005020 ZZ2449=ZZ2449+ZZ2449 -+007112 012040 ZZ2449=ZZ2449+ZZ2449 -+007112 024100 ZZ2449=ZZ2449+ZZ2449 -+007112 050200 ZZ2449=ZZ2449+ZZ2449 -+007112 120400 ZZ2449=ZZ2449+ZZ2449 -+007112 010156 0 8192 -ZZ1449 -+007113 120400 0 ZZ2449 -- mark 3998, 473 /93 leon -+007114 001662 ZZ2450=ZZ2450+ZZ2450 -+007114 003544 ZZ2450=ZZ2450+ZZ2450 -+007114 007310 ZZ2450=ZZ2450+ZZ2450 -+007114 016620 ZZ2450=ZZ2450+ZZ2450 -+007114 035440 ZZ2450=ZZ2450+ZZ2450 -+007114 073100 ZZ2450=ZZ2450+ZZ2450 -+007114 166200 ZZ2450=ZZ2450+ZZ2450 -+007114 354400 ZZ2450=ZZ2450+ZZ2450 -+007114 010142 0 8192 -ZZ1450 -+007115 354400 0 ZZ2450 -- mark 4013, 53 / 5 virg -+007116 000152 ZZ2451=ZZ2451+ZZ2451 -+007116 000324 ZZ2451=ZZ2451+ZZ2451 -+007116 000650 ZZ2451=ZZ2451+ZZ2451 -+007116 001520 ZZ2451=ZZ2451+ZZ2451 -+007116 003240 ZZ2451=ZZ2451+ZZ2451 -+007116 006500 ZZ2451=ZZ2451+ZZ2451 -+007116 015200 ZZ2451=ZZ2451+ZZ2451 -+007116 032400 ZZ2451=ZZ2451+ZZ2451 -+007116 010123 0 8192 -ZZ1451 -+007117 032400 0 ZZ2451 -- mark 4072, 163 / 8 virg -+007120 000506 ZZ2452=ZZ2452+ZZ2452 -+007120 001214 ZZ2452=ZZ2452+ZZ2452 -+007120 002430 ZZ2452=ZZ2452+ZZ2452 -+007120 005060 ZZ2452=ZZ2452+ZZ2452 -+007120 012140 ZZ2452=ZZ2452+ZZ2452 -+007120 024300 ZZ2452=ZZ2452+ZZ2452 -+007120 050600 ZZ2452=ZZ2452+ZZ2452 -+007120 121400 ZZ2452=ZZ2452+ZZ2452 -+007120 010030 0 8192 -ZZ1452 -+007121 121400 0 ZZ2452 -- mark 4097, 211 / 9 virg -+007122 000646 ZZ2453=ZZ2453+ZZ2453 -+007122 001514 ZZ2453=ZZ2453+ZZ2453 -+007122 003230 ZZ2453=ZZ2453+ZZ2453 -+007122 006460 ZZ2453=ZZ2453+ZZ2453 -+007122 015140 ZZ2453=ZZ2453+ZZ2453 -+007122 032300 ZZ2453=ZZ2453+ZZ2453 -+007122 064600 ZZ2453=ZZ2453+ZZ2453 -+007122 151400 ZZ2453=ZZ2453+ZZ2453 -+007122 007777 0 8192 -ZZ1453 -+007123 151400 0 ZZ2453 -- mark 4180, -3 /15 virg -+007124 777770 ZZ2454=ZZ2454+ZZ2454 -+007124 777760 ZZ2454=ZZ2454+ZZ2454 -+007124 777740 ZZ2454=ZZ2454+ZZ2454 -+007124 777700 ZZ2454=ZZ2454+ZZ2454 -+007124 777600 ZZ2454=ZZ2454+ZZ2454 -+007124 777400 ZZ2454=ZZ2454+ZZ2454 -+007124 777000 ZZ2454=ZZ2454+ZZ2454 -+007124 776000 ZZ2454=ZZ2454+ZZ2454 -+007124 007654 0 8192 -ZZ1454 -+007125 776000 0 ZZ2454 -- mark 4185, 418 /11 coma -+007126 001504 ZZ2455=ZZ2455+ZZ2455 -+007126 003210 ZZ2455=ZZ2455+ZZ2455 -+007126 006420 ZZ2455=ZZ2455+ZZ2455 -+007126 015040 ZZ2455=ZZ2455+ZZ2455 -+007126 032100 ZZ2455=ZZ2455+ZZ2455 -+007126 064200 ZZ2455=ZZ2455+ZZ2455 -+007126 150400 ZZ2455=ZZ2455+ZZ2455 -+007126 321000 ZZ2455=ZZ2455+ZZ2455 -+007126 007647 0 8192 -ZZ1455 -+007127 321000 0 ZZ2455 -- mark 4249, -356 / 8 corv -+007130 776466 ZZ2456=ZZ2456+ZZ2456 -+007130 775154 ZZ2456=ZZ2456+ZZ2456 -+007130 772330 ZZ2456=ZZ2456+ZZ2456 -+007130 764660 ZZ2456=ZZ2456+ZZ2456 -+007130 751540 ZZ2456=ZZ2456+ZZ2456 -+007130 723300 ZZ2456=ZZ2456+ZZ2456 -+007130 646600 ZZ2456=ZZ2456+ZZ2456 -+007130 515400 ZZ2456=ZZ2456+ZZ2456 -+007130 007547 0 8192 -ZZ1456 -+007131 515400 0 ZZ2456 -- mark 4290, -170 /26 virg -+007132 777252 ZZ2457=ZZ2457+ZZ2457 -+007132 776524 ZZ2457=ZZ2457+ZZ2457 -+007132 775250 ZZ2457=ZZ2457+ZZ2457 -+007132 772520 ZZ2457=ZZ2457+ZZ2457 -+007132 765240 ZZ2457=ZZ2457+ZZ2457 -+007132 752500 ZZ2457=ZZ2457+ZZ2457 -+007132 725200 ZZ2457=ZZ2457+ZZ2457 -+007132 652400 ZZ2457=ZZ2457+ZZ2457 -+007132 007476 0 8192 -ZZ1457 -+007133 652400 0 ZZ2457 -- mark 4305, 245 /30 virg -+007134 000752 ZZ2458=ZZ2458+ZZ2458 -+007134 001724 ZZ2458=ZZ2458+ZZ2458 -+007134 003650 ZZ2458=ZZ2458+ZZ2458 -+007134 007520 ZZ2458=ZZ2458+ZZ2458 -+007134 017240 ZZ2458=ZZ2458+ZZ2458 -+007134 036500 ZZ2458=ZZ2458+ZZ2458 -+007134 075200 ZZ2458=ZZ2458+ZZ2458 -+007134 172400 ZZ2458=ZZ2458+ZZ2458 -+007134 007457 0 8192 -ZZ1458 -+007135 172400 0 ZZ2458 -- mark 4376, -205 /40 virg -+007136 777144 ZZ2459=ZZ2459+ZZ2459 -+007136 776310 ZZ2459=ZZ2459+ZZ2459 -+007136 774620 ZZ2459=ZZ2459+ZZ2459 -+007136 771440 ZZ2459=ZZ2459+ZZ2459 -+007136 763100 ZZ2459=ZZ2459+ZZ2459 -+007136 746200 ZZ2459=ZZ2459+ZZ2459 -+007136 714400 ZZ2459=ZZ2459+ZZ2459 -+007136 631000 ZZ2459=ZZ2459+ZZ2459 -+007136 007350 0 8192 -ZZ1459 -+007137 631000 0 ZZ2459 -- mark 4403, 409 /36 coma -+007140 001462 ZZ2460=ZZ2460+ZZ2460 -+007140 003144 ZZ2460=ZZ2460+ZZ2460 -+007140 006310 ZZ2460=ZZ2460+ZZ2460 -+007140 014620 ZZ2460=ZZ2460+ZZ2460 -+007140 031440 ZZ2460=ZZ2460+ZZ2460 -+007140 063100 ZZ2460=ZZ2460+ZZ2460 -+007140 146200 ZZ2460=ZZ2460+ZZ2460 -+007140 314400 ZZ2460=ZZ2460+ZZ2460 -+007140 007315 0 8192 -ZZ1460 -+007141 314400 0 ZZ2460 -- mark 4465, -114 /51 virg -+007142 777432 ZZ2461=ZZ2461+ZZ2461 -+007142 777064 ZZ2461=ZZ2461+ZZ2461 -+007142 776150 ZZ2461=ZZ2461+ZZ2461 -+007142 774320 ZZ2461=ZZ2461+ZZ2461 -+007142 770640 ZZ2461=ZZ2461+ZZ2461 -+007142 761500 ZZ2461=ZZ2461+ZZ2461 -+007142 743200 ZZ2461=ZZ2461+ZZ2461 -+007142 706400 ZZ2461=ZZ2461+ZZ2461 -+007142 007217 0 8192 -ZZ1461 -+007143 706400 0 ZZ2461 -- mark 4466, 411 /42 coma -+007144 001466 ZZ2462=ZZ2462+ZZ2462 -+007144 003154 ZZ2462=ZZ2462+ZZ2462 -+007144 006330 ZZ2462=ZZ2462+ZZ2462 -+007144 014660 ZZ2462=ZZ2462+ZZ2462 -+007144 031540 ZZ2462=ZZ2462+ZZ2462 -+007144 063300 ZZ2462=ZZ2462+ZZ2462 -+007144 146600 ZZ2462=ZZ2462+ZZ2462 -+007144 315400 ZZ2462=ZZ2462+ZZ2462 -+007144 007216 0 8192 -ZZ1462 -+007145 315400 0 ZZ2462 -- mark 4512, -404 /61 virg -+007146 776326 ZZ2463=ZZ2463+ZZ2463 -+007146 774654 ZZ2463=ZZ2463+ZZ2463 -+007146 771530 ZZ2463=ZZ2463+ZZ2463 -+007146 763260 ZZ2463=ZZ2463+ZZ2463 -+007146 746540 ZZ2463=ZZ2463+ZZ2463 -+007146 715300 ZZ2463=ZZ2463+ZZ2463 -+007146 632600 ZZ2463=ZZ2463+ZZ2463 -+007146 465400 ZZ2463=ZZ2463+ZZ2463 -+007146 007140 0 8192 -ZZ1463 -+007147 465400 0 ZZ2463 -- mark 4563, -352 /69 virg -+007150 776476 ZZ2464=ZZ2464+ZZ2464 -+007150 775174 ZZ2464=ZZ2464+ZZ2464 -+007150 772370 ZZ2464=ZZ2464+ZZ2464 -+007150 764760 ZZ2464=ZZ2464+ZZ2464 -+007150 751740 ZZ2464=ZZ2464+ZZ2464 -+007150 723700 ZZ2464=ZZ2464+ZZ2464 -+007150 647600 ZZ2464=ZZ2464+ZZ2464 -+007150 517400 ZZ2464=ZZ2464+ZZ2464 -+007150 007055 0 8192 -ZZ1464 -+007151 517400 0 ZZ2464 -- mark 4590, -131 /74 virg -+007152 777370 ZZ2465=ZZ2465+ZZ2465 -+007152 776760 ZZ2465=ZZ2465+ZZ2465 -+007152 775740 ZZ2465=ZZ2465+ZZ2465 -+007152 773700 ZZ2465=ZZ2465+ZZ2465 -+007152 767600 ZZ2465=ZZ2465+ZZ2465 -+007152 757400 ZZ2465=ZZ2465+ZZ2465 -+007152 737000 ZZ2465=ZZ2465+ZZ2465 -+007152 676000 ZZ2465=ZZ2465+ZZ2465 -+007152 007022 0 8192 -ZZ1465 -+007153 676000 0 ZZ2465 -- mark 4603, 95 /78 virg -+007154 000276 ZZ2466=ZZ2466+ZZ2466 -+007154 000574 ZZ2466=ZZ2466+ZZ2466 -+007154 001370 ZZ2466=ZZ2466+ZZ2466 -+007154 002760 ZZ2466=ZZ2466+ZZ2466 -+007154 005740 ZZ2466=ZZ2466+ZZ2466 -+007154 013700 ZZ2466=ZZ2466+ZZ2466 -+007154 027600 ZZ2466=ZZ2466+ZZ2466 -+007154 057400 ZZ2466=ZZ2466+ZZ2466 -+007154 007005 0 8192 -ZZ1466 -+007155 057400 0 ZZ2466 -- mark 4679, 409 / 4 boot -+007156 001462 ZZ2467=ZZ2467+ZZ2467 -+007156 003144 ZZ2467=ZZ2467+ZZ2467 -+007156 006310 ZZ2467=ZZ2467+ZZ2467 -+007156 014620 ZZ2467=ZZ2467+ZZ2467 -+007156 031440 ZZ2467=ZZ2467+ZZ2467 -+007156 063100 ZZ2467=ZZ2467+ZZ2467 -+007156 146200 ZZ2467=ZZ2467+ZZ2467 -+007156 314400 ZZ2467=ZZ2467+ZZ2467 -+007156 006671 0 8192 -ZZ1467 -+007157 314400 0 ZZ2467 -- mark 4691, 371 / 5 boot -+007160 001346 ZZ2468=ZZ2468+ZZ2468 -+007160 002714 ZZ2468=ZZ2468+ZZ2468 -+007160 005630 ZZ2468=ZZ2468+ZZ2468 -+007160 013460 ZZ2468=ZZ2468+ZZ2468 -+007160 027140 ZZ2468=ZZ2468+ZZ2468 -+007160 056300 ZZ2468=ZZ2468+ZZ2468 -+007160 134600 ZZ2468=ZZ2468+ZZ2468 -+007160 271400 ZZ2468=ZZ2468+ZZ2468 -+007160 006655 0 8192 -ZZ1468 -+007161 271400 0 ZZ2468 -- mark 4759, 46 /93 virg -+007162 000134 ZZ2469=ZZ2469+ZZ2469 -+007162 000270 ZZ2469=ZZ2469+ZZ2469 -+007162 000560 ZZ2469=ZZ2469+ZZ2469 -+007162 001340 ZZ2469=ZZ2469+ZZ2469 -+007162 002700 ZZ2469=ZZ2469+ZZ2469 -+007162 005600 ZZ2469=ZZ2469+ZZ2469 -+007162 013400 ZZ2469=ZZ2469+ZZ2469 -+007162 027000 ZZ2469=ZZ2469+ZZ2469 -+007162 006551 0 8192 -ZZ1469 -+007163 027000 0 ZZ2469 -- mark 4820, 66 / -+007164 000204 ZZ2470=ZZ2470+ZZ2470 -+007164 000410 ZZ2470=ZZ2470+ZZ2470 -+007164 001020 ZZ2470=ZZ2470+ZZ2470 -+007164 002040 ZZ2470=ZZ2470+ZZ2470 -+007164 004100 ZZ2470=ZZ2470+ZZ2470 -+007164 010200 ZZ2470=ZZ2470+ZZ2470 -+007164 020400 ZZ2470=ZZ2470+ZZ2470 -+007164 041000 ZZ2470=ZZ2470+ZZ2470 -+007164 006454 0 8192 -ZZ1470 -+007165 041000 0 ZZ2470 -- mark 4822, -223 /98 virg -+007166 777100 ZZ2471=ZZ2471+ZZ2471 -+007166 776200 ZZ2471=ZZ2471+ZZ2471 -+007166 774400 ZZ2471=ZZ2471+ZZ2471 -+007166 771000 ZZ2471=ZZ2471+ZZ2471 -+007166 762000 ZZ2471=ZZ2471+ZZ2471 -+007166 744000 ZZ2471=ZZ2471+ZZ2471 -+007166 710000 ZZ2471=ZZ2471+ZZ2471 -+007166 620000 ZZ2471=ZZ2471+ZZ2471 -+007166 006452 0 8192 -ZZ1471 -+007167 620000 0 ZZ2471 -- mark 4840, -126 /99 virg -+007170 777402 ZZ2472=ZZ2472+ZZ2472 -+007170 777004 ZZ2472=ZZ2472+ZZ2472 -+007170 776010 ZZ2472=ZZ2472+ZZ2472 -+007170 774020 ZZ2472=ZZ2472+ZZ2472 -+007170 770040 ZZ2472=ZZ2472+ZZ2472 -+007170 760100 ZZ2472=ZZ2472+ZZ2472 -+007170 740200 ZZ2472=ZZ2472+ZZ2472 -+007170 700400 ZZ2472=ZZ2472+ZZ2472 -+007170 006430 0 8192 -ZZ1472 -+007171 700400 0 ZZ2472 -- mark 4857, -294 /100 virg -+007172 776662 ZZ2473=ZZ2473+ZZ2473 -+007172 775544 ZZ2473=ZZ2473+ZZ2473 -+007172 773310 ZZ2473=ZZ2473+ZZ2473 -+007172 766620 ZZ2473=ZZ2473+ZZ2473 -+007172 755440 ZZ2473=ZZ2473+ZZ2473 -+007172 733100 ZZ2473=ZZ2473+ZZ2473 -+007172 666200 ZZ2473=ZZ2473+ZZ2473 -+007172 554400 ZZ2473=ZZ2473+ZZ2473 -+007172 006407 0 8192 -ZZ1473 -+007173 554400 0 ZZ2473 -- mark 4864, 382 /20 boot -+007174 001374 ZZ2474=ZZ2474+ZZ2474 -+007174 002770 ZZ2474=ZZ2474+ZZ2474 -+007174 005760 ZZ2474=ZZ2474+ZZ2474 -+007174 013740 ZZ2474=ZZ2474+ZZ2474 -+007174 027700 ZZ2474=ZZ2474+ZZ2474 -+007174 057600 ZZ2474=ZZ2474+ZZ2474 -+007174 137400 ZZ2474=ZZ2474+ZZ2474 -+007174 277000 ZZ2474=ZZ2474+ZZ2474 -+007174 006400 0 8192 -ZZ1474 -+007175 277000 0 ZZ2474 -- mark 4910, -41 /105 virg -+007176 777654 ZZ2475=ZZ2475+ZZ2475 -+007176 777530 ZZ2475=ZZ2475+ZZ2475 -+007176 777260 ZZ2475=ZZ2475+ZZ2475 -+007176 776540 ZZ2475=ZZ2475+ZZ2475 -+007176 775300 ZZ2475=ZZ2475+ZZ2475 -+007176 772600 ZZ2475=ZZ2475+ZZ2475 -+007176 765400 ZZ2475=ZZ2475+ZZ2475 -+007176 753000 ZZ2475=ZZ2475+ZZ2475 -+007176 006322 0 8192 -ZZ1475 -+007177 753000 0 ZZ2475 -- mark 4984, 383 /29 boot -+007200 001376 ZZ2476=ZZ2476+ZZ2476 -+007200 002774 ZZ2476=ZZ2476+ZZ2476 -+007200 005770 ZZ2476=ZZ2476+ZZ2476 -+007200 013760 ZZ2476=ZZ2476+ZZ2476 -+007200 027740 ZZ2476=ZZ2476+ZZ2476 -+007200 057700 ZZ2476=ZZ2476+ZZ2476 -+007200 137600 ZZ2476=ZZ2476+ZZ2476 -+007200 277400 ZZ2476=ZZ2476+ZZ2476 -+007200 006210 0 8192 -ZZ1476 -+007201 277400 0 ZZ2476 -- mark 4986, 322 /30 boot -+007202 001204 ZZ2477=ZZ2477+ZZ2477 -+007202 002410 ZZ2477=ZZ2477+ZZ2477 -+007202 005020 ZZ2477=ZZ2477+ZZ2477 -+007202 012040 ZZ2477=ZZ2477+ZZ2477 -+007202 024100 ZZ2477=ZZ2477+ZZ2477 -+007202 050200 ZZ2477=ZZ2477+ZZ2477 -+007202 120400 ZZ2477=ZZ2477+ZZ2477 -+007202 241000 ZZ2477=ZZ2477+ZZ2477 -+007202 006206 0 8192 -ZZ1477 -+007203 241000 0 ZZ2477 -- mark 4994, -119 /107 virg -+007204 777420 ZZ2478=ZZ2478+ZZ2478 -+007204 777040 ZZ2478=ZZ2478+ZZ2478 -+007204 776100 ZZ2478=ZZ2478+ZZ2478 -+007204 774200 ZZ2478=ZZ2478+ZZ2478 -+007204 770400 ZZ2478=ZZ2478+ZZ2478 -+007204 761000 ZZ2478=ZZ2478+ZZ2478 -+007204 742000 ZZ2478=ZZ2478+ZZ2478 -+007204 704000 ZZ2478=ZZ2478+ZZ2478 -+007204 006176 0 8192 -ZZ1478 -+007205 704000 0 ZZ2478 -- mark 5009, 396 /35 boot -+007206 001430 ZZ2479=ZZ2479+ZZ2479 -+007206 003060 ZZ2479=ZZ2479+ZZ2479 -+007206 006140 ZZ2479=ZZ2479+ZZ2479 -+007206 014300 ZZ2479=ZZ2479+ZZ2479 -+007206 030600 ZZ2479=ZZ2479+ZZ2479 -+007206 061400 ZZ2479=ZZ2479+ZZ2479 -+007206 143000 ZZ2479=ZZ2479+ZZ2479 -+007206 306000 ZZ2479=ZZ2479+ZZ2479 -+007206 006157 0 8192 -ZZ1479 -+007207 306000 0 ZZ2479 -- mark 5013, 53 /109 virg -+007210 000152 ZZ2480=ZZ2480+ZZ2480 -+007210 000324 ZZ2480=ZZ2480+ZZ2480 -+007210 000650 ZZ2480=ZZ2480+ZZ2480 -+007210 001520 ZZ2480=ZZ2480+ZZ2480 -+007210 003240 ZZ2480=ZZ2480+ZZ2480 -+007210 006500 ZZ2480=ZZ2480+ZZ2480 -+007210 015200 ZZ2480=ZZ2480+ZZ2480 -+007210 032400 ZZ2480=ZZ2480+ZZ2480 -+007210 006153 0 8192 -ZZ1480 -+007211 032400 0 ZZ2480 -- mark 5045, 444 /37 boot -+007212 001570 ZZ2481=ZZ2481+ZZ2481 -+007212 003360 ZZ2481=ZZ2481+ZZ2481 -+007212 006740 ZZ2481=ZZ2481+ZZ2481 -+007212 015700 ZZ2481=ZZ2481+ZZ2481 -+007212 033600 ZZ2481=ZZ2481+ZZ2481 -+007212 067400 ZZ2481=ZZ2481+ZZ2481 -+007212 157000 ZZ2481=ZZ2481+ZZ2481 -+007212 336000 ZZ2481=ZZ2481+ZZ2481 -+007212 006113 0 8192 -ZZ1481 -+007213 336000 0 ZZ2481 -- mark 5074, -90 /16 libr -+007214 777512 ZZ2482=ZZ2482+ZZ2482 -+007214 777224 ZZ2482=ZZ2482+ZZ2482 -+007214 776450 ZZ2482=ZZ2482+ZZ2482 -+007214 775120 ZZ2482=ZZ2482+ZZ2482 -+007214 772240 ZZ2482=ZZ2482+ZZ2482 -+007214 764500 ZZ2482=ZZ2482+ZZ2482 -+007214 751200 ZZ2482=ZZ2482+ZZ2482 -+007214 722400 ZZ2482=ZZ2482+ZZ2482 -+007214 006056 0 8192 -ZZ1482 -+007215 722400 0 ZZ2482 -- mark 5108, 57 /110 virg -+007216 000162 ZZ2483=ZZ2483+ZZ2483 -+007216 000344 ZZ2483=ZZ2483+ZZ2483 -+007216 000710 ZZ2483=ZZ2483+ZZ2483 -+007216 001620 ZZ2483=ZZ2483+ZZ2483 -+007216 003440 ZZ2483=ZZ2483+ZZ2483 -+007216 007100 ZZ2483=ZZ2483+ZZ2483 -+007216 016200 ZZ2483=ZZ2483+ZZ2483 -+007216 034400 ZZ2483=ZZ2483+ZZ2483 -+007216 006014 0 8192 -ZZ1483 -+007217 034400 0 ZZ2483 -- mark 5157, -442 /24 libr -+007220 776212 ZZ2484=ZZ2484+ZZ2484 -+007220 774424 ZZ2484=ZZ2484+ZZ2484 -+007220 771050 ZZ2484=ZZ2484+ZZ2484 -+007220 762120 ZZ2484=ZZ2484+ZZ2484 -+007220 744240 ZZ2484=ZZ2484+ZZ2484 -+007220 710500 ZZ2484=ZZ2484+ZZ2484 -+007220 621200 ZZ2484=ZZ2484+ZZ2484 -+007220 442400 ZZ2484=ZZ2484+ZZ2484 -+007220 005733 0 8192 -ZZ1484 -+007221 442400 0 ZZ2484 -- mark 5283, -221 /37 libr -+007222 777104 ZZ2485=ZZ2485+ZZ2485 -+007222 776210 ZZ2485=ZZ2485+ZZ2485 -+007222 774420 ZZ2485=ZZ2485+ZZ2485 -+007222 771040 ZZ2485=ZZ2485+ZZ2485 -+007222 762100 ZZ2485=ZZ2485+ZZ2485 -+007222 744200 ZZ2485=ZZ2485+ZZ2485 -+007222 710400 ZZ2485=ZZ2485+ZZ2485 -+007222 621000 ZZ2485=ZZ2485+ZZ2485 -+007222 005535 0 8192 -ZZ1485 -+007223 621000 0 ZZ2485 -- mark 5290, -329 /38 libr -+007224 776554 ZZ2486=ZZ2486+ZZ2486 -+007224 775330 ZZ2486=ZZ2486+ZZ2486 -+007224 772660 ZZ2486=ZZ2486+ZZ2486 -+007224 765540 ZZ2486=ZZ2486+ZZ2486 -+007224 753300 ZZ2486=ZZ2486+ZZ2486 -+007224 726600 ZZ2486=ZZ2486+ZZ2486 -+007224 655400 ZZ2486=ZZ2486+ZZ2486 -+007224 533000 ZZ2486=ZZ2486+ZZ2486 -+007224 005526 0 8192 -ZZ1486 -+007225 533000 0 ZZ2486 -- mark 5291, 247 /13 serp -+007226 000756 ZZ2487=ZZ2487+ZZ2487 -+007226 001734 ZZ2487=ZZ2487+ZZ2487 -+007226 003670 ZZ2487=ZZ2487+ZZ2487 -+007226 007560 ZZ2487=ZZ2487+ZZ2487 -+007226 017340 ZZ2487=ZZ2487+ZZ2487 -+007226 036700 ZZ2487=ZZ2487+ZZ2487 -+007226 075600 ZZ2487=ZZ2487+ZZ2487 -+007226 173400 ZZ2487=ZZ2487+ZZ2487 -+007226 005525 0 8192 -ZZ1487 -+007227 173400 0 ZZ2487 -- mark 5326, -440 /43 libr -+007230 776216 ZZ2488=ZZ2488+ZZ2488 -+007230 774434 ZZ2488=ZZ2488+ZZ2488 -+007230 771070 ZZ2488=ZZ2488+ZZ2488 -+007230 762160 ZZ2488=ZZ2488+ZZ2488 -+007230 744340 ZZ2488=ZZ2488+ZZ2488 -+007230 710700 ZZ2488=ZZ2488+ZZ2488 -+007230 621600 ZZ2488=ZZ2488+ZZ2488 -+007230 443400 ZZ2488=ZZ2488+ZZ2488 -+007230 005462 0 8192 -ZZ1488 -+007231 443400 0 ZZ2488 -- mark 5331, 455 /21 serp -+007232 001616 ZZ2489=ZZ2489+ZZ2489 -+007232 003434 ZZ2489=ZZ2489+ZZ2489 -+007232 007070 ZZ2489=ZZ2489+ZZ2489 -+007232 016160 ZZ2489=ZZ2489+ZZ2489 -+007232 034340 ZZ2489=ZZ2489+ZZ2489 -+007232 070700 ZZ2489=ZZ2489+ZZ2489 -+007232 161600 ZZ2489=ZZ2489+ZZ2489 -+007232 343400 ZZ2489=ZZ2489+ZZ2489 -+007232 005455 0 8192 -ZZ1489 -+007233 343400 0 ZZ2489 -- mark 5357, 175 /27 serp -+007234 000536 ZZ2490=ZZ2490+ZZ2490 -+007234 001274 ZZ2490=ZZ2490+ZZ2490 -+007234 002570 ZZ2490=ZZ2490+ZZ2490 -+007234 005360 ZZ2490=ZZ2490+ZZ2490 -+007234 012740 ZZ2490=ZZ2490+ZZ2490 -+007234 025700 ZZ2490=ZZ2490+ZZ2490 -+007234 053600 ZZ2490=ZZ2490+ZZ2490 -+007234 127400 ZZ2490=ZZ2490+ZZ2490 -+007234 005423 0 8192 -ZZ1490 -+007235 127400 0 ZZ2490 -- mark 5372, 420 /35 serp -+007236 001510 ZZ2491=ZZ2491+ZZ2491 -+007236 003220 ZZ2491=ZZ2491+ZZ2491 -+007236 006440 ZZ2491=ZZ2491+ZZ2491 -+007236 015100 ZZ2491=ZZ2491+ZZ2491 -+007236 032200 ZZ2491=ZZ2491+ZZ2491 -+007236 064400 ZZ2491=ZZ2491+ZZ2491 -+007236 151000 ZZ2491=ZZ2491+ZZ2491 -+007236 322000 ZZ2491=ZZ2491+ZZ2491 -+007236 005404 0 8192 -ZZ1491 -+007237 322000 0 ZZ2491 -- mark 5381, 109 /37 serp -+007240 000332 ZZ2492=ZZ2492+ZZ2492 -+007240 000664 ZZ2492=ZZ2492+ZZ2492 -+007240 001550 ZZ2492=ZZ2492+ZZ2492 -+007240 003320 ZZ2492=ZZ2492+ZZ2492 -+007240 006640 ZZ2492=ZZ2492+ZZ2492 -+007240 015500 ZZ2492=ZZ2492+ZZ2492 -+007240 033200 ZZ2492=ZZ2492+ZZ2492 -+007240 066400 ZZ2492=ZZ2492+ZZ2492 -+007240 005373 0 8192 -ZZ1492 -+007241 066400 0 ZZ2492 -- mark 5387, 484 /38 serp -+007242 001710 ZZ2493=ZZ2493+ZZ2493 -+007242 003620 ZZ2493=ZZ2493+ZZ2493 -+007242 007440 ZZ2493=ZZ2493+ZZ2493 -+007242 017100 ZZ2493=ZZ2493+ZZ2493 -+007242 036200 ZZ2493=ZZ2493+ZZ2493 -+007242 074400 ZZ2493=ZZ2493+ZZ2493 -+007242 171000 ZZ2493=ZZ2493+ZZ2493 -+007242 362000 ZZ2493=ZZ2493+ZZ2493 -+007242 005365 0 8192 -ZZ1493 -+007243 362000 0 ZZ2493 -- mark 5394, -374 /46 libr -+007244 776422 ZZ2494=ZZ2494+ZZ2494 -+007244 775044 ZZ2494=ZZ2494+ZZ2494 -+007244 772110 ZZ2494=ZZ2494+ZZ2494 -+007244 764220 ZZ2494=ZZ2494+ZZ2494 -+007244 750440 ZZ2494=ZZ2494+ZZ2494 -+007244 721100 ZZ2494=ZZ2494+ZZ2494 -+007244 642200 ZZ2494=ZZ2494+ZZ2494 -+007244 504400 ZZ2494=ZZ2494+ZZ2494 -+007244 005356 0 8192 -ZZ1494 -+007245 504400 0 ZZ2494 -- mark 5415, 364 /41 serp -+007246 001330 ZZ2495=ZZ2495+ZZ2495 -+007246 002660 ZZ2495=ZZ2495+ZZ2495 -+007246 005540 ZZ2495=ZZ2495+ZZ2495 -+007246 013300 ZZ2495=ZZ2495+ZZ2495 -+007246 026600 ZZ2495=ZZ2495+ZZ2495 -+007246 055400 ZZ2495=ZZ2495+ZZ2495 -+007246 133000 ZZ2495=ZZ2495+ZZ2495 -+007246 266000 ZZ2495=ZZ2495+ZZ2495 -+007246 005331 0 8192 -ZZ1495 -+007247 266000 0 ZZ2495 -- mark 5419, -318 /48 libr -+007250 776602 ZZ2496=ZZ2496+ZZ2496 -+007250 775404 ZZ2496=ZZ2496+ZZ2496 -+007250 773010 ZZ2496=ZZ2496+ZZ2496 -+007250 766020 ZZ2496=ZZ2496+ZZ2496 -+007250 754040 ZZ2496=ZZ2496+ZZ2496 -+007250 730100 ZZ2496=ZZ2496+ZZ2496 -+007250 660200 ZZ2496=ZZ2496+ZZ2496 -+007250 540400 ZZ2496=ZZ2496+ZZ2496 -+007250 005325 0 8192 -ZZ1496 -+007251 540400 0 ZZ2496 -- mark 5455, -253 /xi scor -+007252 777004 ZZ2497=ZZ2497+ZZ2497 -+007252 776010 ZZ2497=ZZ2497+ZZ2497 -+007252 774020 ZZ2497=ZZ2497+ZZ2497 -+007252 770040 ZZ2497=ZZ2497+ZZ2497 -+007252 760100 ZZ2497=ZZ2497+ZZ2497 -+007252 740200 ZZ2497=ZZ2497+ZZ2497 -+007252 700400 ZZ2497=ZZ2497+ZZ2497 -+007252 601000 ZZ2497=ZZ2497+ZZ2497 -+007252 005261 0 8192 -ZZ1497 -+007253 601000 0 ZZ2497 -- mark 5467, -464 / 9 scor -+007254 776136 ZZ2498=ZZ2498+ZZ2498 -+007254 774274 ZZ2498=ZZ2498+ZZ2498 -+007254 770570 ZZ2498=ZZ2498+ZZ2498 -+007254 761360 ZZ2498=ZZ2498+ZZ2498 -+007254 742740 ZZ2498=ZZ2498+ZZ2498 -+007254 705700 ZZ2498=ZZ2498+ZZ2498 -+007254 613600 ZZ2498=ZZ2498+ZZ2498 -+007254 427400 ZZ2498=ZZ2498+ZZ2498 -+007254 005245 0 8192 -ZZ1498 -+007255 427400 0 ZZ2498 -- mark 5470, -469 /10 scor -+007256 776124 ZZ2499=ZZ2499+ZZ2499 -+007256 774250 ZZ2499=ZZ2499+ZZ2499 -+007256 770520 ZZ2499=ZZ2499+ZZ2499 -+007256 761240 ZZ2499=ZZ2499+ZZ2499 -+007256 742500 ZZ2499=ZZ2499+ZZ2499 -+007256 705200 ZZ2499=ZZ2499+ZZ2499 -+007256 612400 ZZ2499=ZZ2499+ZZ2499 -+007256 425000 ZZ2499=ZZ2499+ZZ2499 -+007256 005242 0 8192 -ZZ1499 -+007257 425000 0 ZZ2499 -- mark 5497, -437 /14 scor -+007260 776224 ZZ2500=ZZ2500+ZZ2500 -+007260 774450 ZZ2500=ZZ2500+ZZ2500 -+007260 771120 ZZ2500=ZZ2500+ZZ2500 -+007260 762240 ZZ2500=ZZ2500+ZZ2500 -+007260 744500 ZZ2500=ZZ2500+ZZ2500 -+007260 711200 ZZ2500=ZZ2500+ZZ2500 -+007260 622400 ZZ2500=ZZ2500+ZZ2500 -+007260 445000 ZZ2500=ZZ2500+ZZ2500 -+007260 005207 0 8192 -ZZ1500 -+007261 445000 0 ZZ2500 -- mark 5499, -223 /15 scor -+007262 777100 ZZ2501=ZZ2501+ZZ2501 -+007262 776200 ZZ2501=ZZ2501+ZZ2501 -+007262 774400 ZZ2501=ZZ2501+ZZ2501 -+007262 771000 ZZ2501=ZZ2501+ZZ2501 -+007262 762000 ZZ2501=ZZ2501+ZZ2501 -+007262 744000 ZZ2501=ZZ2501+ZZ2501 -+007262 710000 ZZ2501=ZZ2501+ZZ2501 -+007262 620000 ZZ2501=ZZ2501+ZZ2501 -+007262 005205 0 8192 -ZZ1501 -+007263 620000 0 ZZ2501 -- mark 5558, 29 /50 serp -+007264 000072 ZZ2502=ZZ2502+ZZ2502 -+007264 000164 ZZ2502=ZZ2502+ZZ2502 -+007264 000350 ZZ2502=ZZ2502+ZZ2502 -+007264 000720 ZZ2502=ZZ2502+ZZ2502 -+007264 001640 ZZ2502=ZZ2502+ZZ2502 -+007264 003500 ZZ2502=ZZ2502+ZZ2502 -+007264 007200 ZZ2502=ZZ2502+ZZ2502 -+007264 016400 ZZ2502=ZZ2502+ZZ2502 -+007264 005112 0 8192 -ZZ1502 -+007265 016400 0 ZZ2502 -- mark 5561, 441 /20 herc -+007266 001562 ZZ2503=ZZ2503+ZZ2503 -+007266 003344 ZZ2503=ZZ2503+ZZ2503 -+007266 006710 ZZ2503=ZZ2503+ZZ2503 -+007266 015620 ZZ2503=ZZ2503+ZZ2503 -+007266 033440 ZZ2503=ZZ2503+ZZ2503 -+007266 067100 ZZ2503=ZZ2503+ZZ2503 -+007266 156200 ZZ2503=ZZ2503+ZZ2503 -+007266 334400 ZZ2503=ZZ2503+ZZ2503 -+007266 005107 0 8192 -ZZ1503 -+007267 334400 0 ZZ2503 -- mark 5565, -451 / 4 ophi -+007270 776170 ZZ2504=ZZ2504+ZZ2504 -+007270 774360 ZZ2504=ZZ2504+ZZ2504 -+007270 770740 ZZ2504=ZZ2504+ZZ2504 -+007270 761700 ZZ2504=ZZ2504+ZZ2504 -+007270 743600 ZZ2504=ZZ2504+ZZ2504 -+007270 707400 ZZ2504=ZZ2504+ZZ2504 -+007270 617000 ZZ2504=ZZ2504+ZZ2504 -+007270 436000 ZZ2504=ZZ2504+ZZ2504 -+007270 005103 0 8192 -ZZ1504 -+007271 436000 0 ZZ2504 -- mark 5580, 325 /24 herc -+007272 001212 ZZ2505=ZZ2505+ZZ2505 -+007272 002424 ZZ2505=ZZ2505+ZZ2505 -+007272 005050 ZZ2505=ZZ2505+ZZ2505 -+007272 012120 ZZ2505=ZZ2505+ZZ2505 -+007272 024240 ZZ2505=ZZ2505+ZZ2505 -+007272 050500 ZZ2505=ZZ2505+ZZ2505 -+007272 121200 ZZ2505=ZZ2505+ZZ2505 -+007272 242400 ZZ2505=ZZ2505+ZZ2505 -+007272 005064 0 8192 -ZZ1505 -+007273 242400 0 ZZ2505 -- mark 5582, -415 / 7 ophi -+007274 776300 ZZ2506=ZZ2506+ZZ2506 -+007274 774600 ZZ2506=ZZ2506+ZZ2506 -+007274 771400 ZZ2506=ZZ2506+ZZ2506 -+007274 763000 ZZ2506=ZZ2506+ZZ2506 -+007274 746000 ZZ2506=ZZ2506+ZZ2506 -+007274 714000 ZZ2506=ZZ2506+ZZ2506 -+007274 630000 ZZ2506=ZZ2506+ZZ2506 -+007274 460000 ZZ2506=ZZ2506+ZZ2506 -+007274 005062 0 8192 -ZZ1506 -+007275 460000 0 ZZ2506 -- mark 5589, -186 / 3 ophi -+007276 777212 ZZ2507=ZZ2507+ZZ2507 -+007276 776424 ZZ2507=ZZ2507+ZZ2507 -+007276 775050 ZZ2507=ZZ2507+ZZ2507 -+007276 772120 ZZ2507=ZZ2507+ZZ2507 -+007276 764240 ZZ2507=ZZ2507+ZZ2507 -+007276 750500 ZZ2507=ZZ2507+ZZ2507 -+007276 721200 ZZ2507=ZZ2507+ZZ2507 -+007276 642400 ZZ2507=ZZ2507+ZZ2507 -+007276 005053 0 8192 -ZZ1507 -+007277 642400 0 ZZ2507 -- mark 5606, -373 / 8 ophi -+007300 776424 ZZ2508=ZZ2508+ZZ2508 -+007300 775050 ZZ2508=ZZ2508+ZZ2508 -+007300 772120 ZZ2508=ZZ2508+ZZ2508 -+007300 764240 ZZ2508=ZZ2508+ZZ2508 -+007300 750500 ZZ2508=ZZ2508+ZZ2508 -+007300 721200 ZZ2508=ZZ2508+ZZ2508 -+007300 642400 ZZ2508=ZZ2508+ZZ2508 -+007300 505000 ZZ2508=ZZ2508+ZZ2508 -+007300 005032 0 8192 -ZZ1508 -+007301 505000 0 ZZ2508 -- mark 5609, 50 /10 ophi -+007302 000144 ZZ2509=ZZ2509+ZZ2509 -+007302 000310 ZZ2509=ZZ2509+ZZ2509 -+007302 000620 ZZ2509=ZZ2509+ZZ2509 -+007302 001440 ZZ2509=ZZ2509+ZZ2509 -+007302 003100 ZZ2509=ZZ2509+ZZ2509 -+007302 006200 ZZ2509=ZZ2509+ZZ2509 -+007302 014400 ZZ2509=ZZ2509+ZZ2509 -+007302 031000 ZZ2509=ZZ2509+ZZ2509 -+007302 005027 0 8192 -ZZ1509 -+007303 031000 0 ZZ2509 -- mark 5610, -484 / 9 ophi -+007304 776066 ZZ2510=ZZ2510+ZZ2510 -+007304 774154 ZZ2510=ZZ2510+ZZ2510 -+007304 770330 ZZ2510=ZZ2510+ZZ2510 -+007304 760660 ZZ2510=ZZ2510+ZZ2510 -+007304 741540 ZZ2510=ZZ2510+ZZ2510 -+007304 703300 ZZ2510=ZZ2510+ZZ2510 -+007304 606600 ZZ2510=ZZ2510+ZZ2510 -+007304 415400 ZZ2510=ZZ2510+ZZ2510 -+007304 005026 0 8192 -ZZ1510 -+007305 415400 0 ZZ2510 -- mark 5620, 266 /29 herc -+007306 001024 ZZ2511=ZZ2511+ZZ2511 -+007306 002050 ZZ2511=ZZ2511+ZZ2511 -+007306 004120 ZZ2511=ZZ2511+ZZ2511 -+007306 010240 ZZ2511=ZZ2511+ZZ2511 -+007306 020500 ZZ2511=ZZ2511+ZZ2511 -+007306 041200 ZZ2511=ZZ2511+ZZ2511 -+007306 102400 ZZ2511=ZZ2511+ZZ2511 -+007306 205000 ZZ2511=ZZ2511+ZZ2511 -+007306 005014 0 8192 -ZZ1511 -+007307 205000 0 ZZ2511 -- mark 5713, -241 /20 ophi -+007310 777034 ZZ2512=ZZ2512+ZZ2512 -+007310 776070 ZZ2512=ZZ2512+ZZ2512 -+007310 774160 ZZ2512=ZZ2512+ZZ2512 -+007310 770340 ZZ2512=ZZ2512+ZZ2512 -+007310 760700 ZZ2512=ZZ2512+ZZ2512 -+007310 741600 ZZ2512=ZZ2512+ZZ2512 -+007310 703400 ZZ2512=ZZ2512+ZZ2512 -+007310 607000 ZZ2512=ZZ2512+ZZ2512 -+007310 004657 0 8192 -ZZ1512 -+007311 607000 0 ZZ2512 -- mark 5742, 235 /25 ophi -+007312 000726 ZZ2513=ZZ2513+ZZ2513 -+007312 001654 ZZ2513=ZZ2513+ZZ2513 -+007312 003530 ZZ2513=ZZ2513+ZZ2513 -+007312 007260 ZZ2513=ZZ2513+ZZ2513 -+007312 016540 ZZ2513=ZZ2513+ZZ2513 -+007312 035300 ZZ2513=ZZ2513+ZZ2513 -+007312 072600 ZZ2513=ZZ2513+ZZ2513 -+007312 165400 ZZ2513=ZZ2513+ZZ2513 -+007312 004622 0 8192 -ZZ1513 -+007313 165400 0 ZZ2513 -- mark 5763, 217 /27 ophi -+007314 000662 ZZ2514=ZZ2514+ZZ2514 -+007314 001544 ZZ2514=ZZ2514+ZZ2514 -+007314 003310 ZZ2514=ZZ2514+ZZ2514 -+007314 006620 ZZ2514=ZZ2514+ZZ2514 -+007314 015440 ZZ2514=ZZ2514+ZZ2514 -+007314 033100 ZZ2514=ZZ2514+ZZ2514 -+007314 066200 ZZ2514=ZZ2514+ZZ2514 -+007314 154400 ZZ2514=ZZ2514+ZZ2514 -+007314 004575 0 8192 -ZZ1514 -+007315 154400 0 ZZ2514 -- mark 5807, 293 /60 herc -+007316 001112 ZZ2515=ZZ2515+ZZ2515 -+007316 002224 ZZ2515=ZZ2515+ZZ2515 -+007316 004450 ZZ2515=ZZ2515+ZZ2515 -+007316 011120 ZZ2515=ZZ2515+ZZ2515 -+007316 022240 ZZ2515=ZZ2515+ZZ2515 -+007316 044500 ZZ2515=ZZ2515+ZZ2515 -+007316 111200 ZZ2515=ZZ2515+ZZ2515 -+007316 222400 ZZ2515=ZZ2515+ZZ2515 -+007316 004521 0 8192 -ZZ1515 -+007317 222400 0 ZZ2515 -- mark 5868, -8 /41 ophi -+007320 777756 ZZ2516=ZZ2516+ZZ2516 -+007320 777734 ZZ2516=ZZ2516+ZZ2516 -+007320 777670 ZZ2516=ZZ2516+ZZ2516 -+007320 777560 ZZ2516=ZZ2516+ZZ2516 -+007320 777340 ZZ2516=ZZ2516+ZZ2516 -+007320 776700 ZZ2516=ZZ2516+ZZ2516 -+007320 775600 ZZ2516=ZZ2516+ZZ2516 -+007320 773400 ZZ2516=ZZ2516+ZZ2516 -+007320 004424 0 8192 -ZZ1516 -+007321 773400 0 ZZ2516 -- mark 5888, -478 /40 ophi -+007322 776102 ZZ2517=ZZ2517+ZZ2517 -+007322 774204 ZZ2517=ZZ2517+ZZ2517 -+007322 770410 ZZ2517=ZZ2517+ZZ2517 -+007322 761020 ZZ2517=ZZ2517+ZZ2517 -+007322 742040 ZZ2517=ZZ2517+ZZ2517 -+007322 704100 ZZ2517=ZZ2517+ZZ2517 -+007322 610200 ZZ2517=ZZ2517+ZZ2517 -+007322 420400 ZZ2517=ZZ2517+ZZ2517 -+007322 004400 0 8192 -ZZ1517 -+007323 420400 0 ZZ2517 -- mark 5889, -290 /53 serp -+007324 776672 ZZ2518=ZZ2518+ZZ2518 -+007324 775564 ZZ2518=ZZ2518+ZZ2518 -+007324 773350 ZZ2518=ZZ2518+ZZ2518 -+007324 766720 ZZ2518=ZZ2518+ZZ2518 -+007324 755640 ZZ2518=ZZ2518+ZZ2518 -+007324 733500 ZZ2518=ZZ2518+ZZ2518 -+007324 667200 ZZ2518=ZZ2518+ZZ2518 -+007324 556400 ZZ2518=ZZ2518+ZZ2518 -+007324 004377 0 8192 -ZZ1518 -+007325 556400 0 ZZ2518 -- mark 5924, -114 / -+007326 777432 ZZ2519=ZZ2519+ZZ2519 -+007326 777064 ZZ2519=ZZ2519+ZZ2519 -+007326 776150 ZZ2519=ZZ2519+ZZ2519 -+007326 774320 ZZ2519=ZZ2519+ZZ2519 -+007326 770640 ZZ2519=ZZ2519+ZZ2519 -+007326 761500 ZZ2519=ZZ2519+ZZ2519 -+007326 743200 ZZ2519=ZZ2519+ZZ2519 -+007326 706400 ZZ2519=ZZ2519+ZZ2519 -+007326 004334 0 8192 -ZZ1519 -+007327 706400 0 ZZ2519 -- mark 5925, 96 /49 ophi -+007330 000300 ZZ2520=ZZ2520+ZZ2520 -+007330 000600 ZZ2520=ZZ2520+ZZ2520 -+007330 001400 ZZ2520=ZZ2520+ZZ2520 -+007330 003000 ZZ2520=ZZ2520+ZZ2520 -+007330 006000 ZZ2520=ZZ2520+ZZ2520 -+007330 014000 ZZ2520=ZZ2520+ZZ2520 -+007330 030000 ZZ2520=ZZ2520+ZZ2520 -+007330 060000 ZZ2520=ZZ2520+ZZ2520 -+007330 004333 0 8192 -ZZ1520 -+007331 060000 0 ZZ2520 -- mark 5987, -183 /57 ophi -+007332 777220 ZZ2521=ZZ2521+ZZ2521 -+007332 776440 ZZ2521=ZZ2521+ZZ2521 -+007332 775100 ZZ2521=ZZ2521+ZZ2521 -+007332 772200 ZZ2521=ZZ2521+ZZ2521 -+007332 764400 ZZ2521=ZZ2521+ZZ2521 -+007332 751000 ZZ2521=ZZ2521+ZZ2521 -+007332 722000 ZZ2521=ZZ2521+ZZ2521 -+007332 644000 ZZ2521=ZZ2521+ZZ2521 -+007332 004235 0 8192 -ZZ1521 -+007333 644000 0 ZZ2521 -- mark 6006, -292 /56 serp -+007334 776666 ZZ2522=ZZ2522+ZZ2522 -+007334 775554 ZZ2522=ZZ2522+ZZ2522 -+007334 773330 ZZ2522=ZZ2522+ZZ2522 -+007334 766660 ZZ2522=ZZ2522+ZZ2522 -+007334 755540 ZZ2522=ZZ2522+ZZ2522 -+007334 733300 ZZ2522=ZZ2522+ZZ2522 -+007334 666600 ZZ2522=ZZ2522+ZZ2522 -+007334 555400 ZZ2522=ZZ2522+ZZ2522 -+007334 004212 0 8192 -ZZ1522 -+007335 555400 0 ZZ2522 -- mark 6016, -492 /58 ophi -+007336 776046 ZZ2523=ZZ2523+ZZ2523 -+007336 774114 ZZ2523=ZZ2523+ZZ2523 -+007336 770230 ZZ2523=ZZ2523+ZZ2523 -+007336 760460 ZZ2523=ZZ2523+ZZ2523 -+007336 741140 ZZ2523=ZZ2523+ZZ2523 -+007336 702300 ZZ2523=ZZ2523+ZZ2523 -+007336 604600 ZZ2523=ZZ2523+ZZ2523 -+007336 411400 ZZ2523=ZZ2523+ZZ2523 -+007336 004200 0 8192 -ZZ1523 -+007337 411400 0 ZZ2523 -- mark 6117, -84 /57 serp -+007340 777526 ZZ2524=ZZ2524+ZZ2524 -+007340 777254 ZZ2524=ZZ2524+ZZ2524 -+007340 776530 ZZ2524=ZZ2524+ZZ2524 -+007340 775260 ZZ2524=ZZ2524+ZZ2524 -+007340 772540 ZZ2524=ZZ2524+ZZ2524 -+007340 765300 ZZ2524=ZZ2524+ZZ2524 -+007340 752600 ZZ2524=ZZ2524+ZZ2524 -+007340 725400 ZZ2524=ZZ2524+ZZ2524 -+007340 004033 0 8192 -ZZ1524 -+007341 725400 0 ZZ2524 -- mark 6117, 99 /66 ophi -+007342 000306 ZZ2525=ZZ2525+ZZ2525 -+007342 000614 ZZ2525=ZZ2525+ZZ2525 -+007342 001430 ZZ2525=ZZ2525+ZZ2525 -+007342 003060 ZZ2525=ZZ2525+ZZ2525 -+007342 006140 ZZ2525=ZZ2525+ZZ2525 -+007342 014300 ZZ2525=ZZ2525+ZZ2525 -+007342 030600 ZZ2525=ZZ2525+ZZ2525 -+007342 061400 ZZ2525=ZZ2525+ZZ2525 -+007342 004033 0 8192 -ZZ1525 -+007343 061400 0 ZZ2525 -- mark 6119, 381 /93 herc -+007344 001372 ZZ2526=ZZ2526+ZZ2526 -+007344 002764 ZZ2526=ZZ2526+ZZ2526 -+007344 005750 ZZ2526=ZZ2526+ZZ2526 -+007344 013720 ZZ2526=ZZ2526+ZZ2526 -+007344 027640 ZZ2526=ZZ2526+ZZ2526 -+007344 057500 ZZ2526=ZZ2526+ZZ2526 -+007344 137200 ZZ2526=ZZ2526+ZZ2526 -+007344 276400 ZZ2526=ZZ2526+ZZ2526 -+007344 004031 0 8192 -ZZ1526 -+007345 276400 0 ZZ2526 -- mark 6119, 67 /67 ophi -+007346 000206 ZZ2527=ZZ2527+ZZ2527 -+007346 000414 ZZ2527=ZZ2527+ZZ2527 -+007346 001030 ZZ2527=ZZ2527+ZZ2527 -+007346 002060 ZZ2527=ZZ2527+ZZ2527 -+007346 004140 ZZ2527=ZZ2527+ZZ2527 -+007346 010300 ZZ2527=ZZ2527+ZZ2527 -+007346 020600 ZZ2527=ZZ2527+ZZ2527 -+007346 041400 ZZ2527=ZZ2527+ZZ2527 -+007346 004031 0 8192 -ZZ1527 -+007347 041400 0 ZZ2527 -- mark 6125, 30 /68 ophi -+007350 000074 ZZ2528=ZZ2528+ZZ2528 -+007350 000170 ZZ2528=ZZ2528+ZZ2528 -+007350 000360 ZZ2528=ZZ2528+ZZ2528 -+007350 000740 ZZ2528=ZZ2528+ZZ2528 -+007350 001700 ZZ2528=ZZ2528+ZZ2528 -+007350 003600 ZZ2528=ZZ2528+ZZ2528 -+007350 007400 ZZ2528=ZZ2528+ZZ2528 -+007350 017000 ZZ2528=ZZ2528+ZZ2528 -+007350 004023 0 8192 -ZZ1528 -+007351 017000 0 ZZ2528 -- mark 6146, 57 /70 ophi -+007352 000162 ZZ2529=ZZ2529+ZZ2529 -+007352 000344 ZZ2529=ZZ2529+ZZ2529 -+007352 000710 ZZ2529=ZZ2529+ZZ2529 -+007352 001620 ZZ2529=ZZ2529+ZZ2529 -+007352 003440 ZZ2529=ZZ2529+ZZ2529 -+007352 007100 ZZ2529=ZZ2529+ZZ2529 -+007352 016200 ZZ2529=ZZ2529+ZZ2529 -+007352 034400 ZZ2529=ZZ2529+ZZ2529 -+007352 003776 0 8192 -ZZ1529 -+007353 034400 0 ZZ2529 -- mark 6158, 198 /71 ophi -+007354 000614 ZZ2530=ZZ2530+ZZ2530 -+007354 001430 ZZ2530=ZZ2530+ZZ2530 -+007354 003060 ZZ2530=ZZ2530+ZZ2530 -+007354 006140 ZZ2530=ZZ2530+ZZ2530 -+007354 014300 ZZ2530=ZZ2530+ZZ2530 -+007354 030600 ZZ2530=ZZ2530+ZZ2530 -+007354 061400 ZZ2530=ZZ2530+ZZ2530 -+007354 143000 ZZ2530=ZZ2530+ZZ2530 -+007354 003762 0 8192 -ZZ1530 -+007355 143000 0 ZZ2530 -- mark 6170, 473 /102 herc -+007356 001662 ZZ2531=ZZ2531+ZZ2531 -+007356 003544 ZZ2531=ZZ2531+ZZ2531 -+007356 007310 ZZ2531=ZZ2531+ZZ2531 -+007356 016620 ZZ2531=ZZ2531+ZZ2531 -+007356 035440 ZZ2531=ZZ2531+ZZ2531 -+007356 073100 ZZ2531=ZZ2531+ZZ2531 -+007356 166200 ZZ2531=ZZ2531+ZZ2531 -+007356 354400 ZZ2531=ZZ2531+ZZ2531 -+007356 003746 0 8192 -ZZ1531 -+007357 354400 0 ZZ2531 -- mark 6188, -480 /13 sgtr -+007360 776076 ZZ2532=ZZ2532+ZZ2532 -+007360 774174 ZZ2532=ZZ2532+ZZ2532 -+007360 770370 ZZ2532=ZZ2532+ZZ2532 -+007360 760760 ZZ2532=ZZ2532+ZZ2532 -+007360 741740 ZZ2532=ZZ2532+ZZ2532 -+007360 703700 ZZ2532=ZZ2532+ZZ2532 -+007360 607600 ZZ2532=ZZ2532+ZZ2532 -+007360 417400 ZZ2532=ZZ2532+ZZ2532 -+007360 003724 0 8192 -ZZ1532 -+007361 417400 0 ZZ2532 -- mark 6234, 76 /74 ophi -+007362 000230 ZZ2533=ZZ2533+ZZ2533 -+007362 000460 ZZ2533=ZZ2533+ZZ2533 -+007362 001140 ZZ2533=ZZ2533+ZZ2533 -+007362 002300 ZZ2533=ZZ2533+ZZ2533 -+007362 004600 ZZ2533=ZZ2533+ZZ2533 -+007362 011400 ZZ2533=ZZ2533+ZZ2533 -+007362 023000 ZZ2533=ZZ2533+ZZ2533 -+007362 046000 ZZ2533=ZZ2533+ZZ2533 -+007362 003646 0 8192 -ZZ1533 -+007363 046000 0 ZZ2533 -- mark 6235, 499 /106 herc -+007364 001746 ZZ2534=ZZ2534+ZZ2534 -+007364 003714 ZZ2534=ZZ2534+ZZ2534 -+007364 007630 ZZ2534=ZZ2534+ZZ2534 -+007364 017460 ZZ2534=ZZ2534+ZZ2534 -+007364 037140 ZZ2534=ZZ2534+ZZ2534 -+007364 076300 ZZ2534=ZZ2534+ZZ2534 -+007364 174600 ZZ2534=ZZ2534+ZZ2534 -+007364 371400 ZZ2534=ZZ2534+ZZ2534 -+007364 003645 0 8192 -ZZ1534 -+007365 371400 0 ZZ2534 -- mark 6247, -204 /xi scut -+007366 777146 ZZ2535=ZZ2535+ZZ2535 -+007366 776314 ZZ2535=ZZ2535+ZZ2535 -+007366 774630 ZZ2535=ZZ2535+ZZ2535 -+007366 771460 ZZ2535=ZZ2535+ZZ2535 -+007366 763140 ZZ2535=ZZ2535+ZZ2535 -+007366 746300 ZZ2535=ZZ2535+ZZ2535 -+007366 714600 ZZ2535=ZZ2535+ZZ2535 -+007366 631400 ZZ2535=ZZ2535+ZZ2535 -+007366 003631 0 8192 -ZZ1535 -+007367 631400 0 ZZ2535 -- mark 6254, -469 /21 sgtr -+007370 776124 ZZ2536=ZZ2536+ZZ2536 -+007370 774250 ZZ2536=ZZ2536+ZZ2536 -+007370 770520 ZZ2536=ZZ2536+ZZ2536 -+007370 761240 ZZ2536=ZZ2536+ZZ2536 -+007370 742500 ZZ2536=ZZ2536+ZZ2536 -+007370 705200 ZZ2536=ZZ2536+ZZ2536 -+007370 612400 ZZ2536=ZZ2536+ZZ2536 -+007370 425000 ZZ2536=ZZ2536+ZZ2536 -+007370 003622 0 8192 -ZZ1536 -+007371 425000 0 ZZ2536 -- mark 6255, 494 /109 herc -+007372 001734 ZZ2537=ZZ2537+ZZ2537 -+007372 003670 ZZ2537=ZZ2537+ZZ2537 -+007372 007560 ZZ2537=ZZ2537+ZZ2537 -+007372 017340 ZZ2537=ZZ2537+ZZ2537 -+007372 036700 ZZ2537=ZZ2537+ZZ2537 -+007372 075600 ZZ2537=ZZ2537+ZZ2537 -+007372 173400 ZZ2537=ZZ2537+ZZ2537 -+007372 367000 ZZ2537=ZZ2537+ZZ2537 -+007372 003621 0 8192 -ZZ1537 -+007373 367000 0 ZZ2537 -- mark 6278, -333 /ga scut -+007374 776544 ZZ2538=ZZ2538+ZZ2538 -+007374 775310 ZZ2538=ZZ2538+ZZ2538 -+007374 772620 ZZ2538=ZZ2538+ZZ2538 -+007374 765440 ZZ2538=ZZ2538+ZZ2538 -+007374 753100 ZZ2538=ZZ2538+ZZ2538 -+007374 726200 ZZ2538=ZZ2538+ZZ2538 -+007374 654400 ZZ2538=ZZ2538+ZZ2538 -+007374 531000 ZZ2538=ZZ2538+ZZ2538 -+007374 003572 0 8192 -ZZ1538 -+007375 531000 0 ZZ2538 -- mark 6313, -189 /al scut -+007376 777204 ZZ2539=ZZ2539+ZZ2539 -+007376 776410 ZZ2539=ZZ2539+ZZ2539 -+007376 775020 ZZ2539=ZZ2539+ZZ2539 -+007376 772040 ZZ2539=ZZ2539+ZZ2539 -+007376 764100 ZZ2539=ZZ2539+ZZ2539 -+007376 750200 ZZ2539=ZZ2539+ZZ2539 -+007376 720400 ZZ2539=ZZ2539+ZZ2539 -+007376 641000 ZZ2539=ZZ2539+ZZ2539 -+007376 003527 0 8192 -ZZ1539 -+007377 641000 0 ZZ2539 -- mark 6379, 465 /110 herc -+007400 001642 ZZ2540=ZZ2540+ZZ2540 -+007400 003504 ZZ2540=ZZ2540+ZZ2540 -+007400 007210 ZZ2540=ZZ2540+ZZ2540 -+007400 016420 ZZ2540=ZZ2540+ZZ2540 -+007400 035040 ZZ2540=ZZ2540+ZZ2540 -+007400 072100 ZZ2540=ZZ2540+ZZ2540 -+007400 164200 ZZ2540=ZZ2540+ZZ2540 -+007400 350400 ZZ2540=ZZ2540+ZZ2540 -+007400 003425 0 8192 -ZZ1540 -+007401 350400 0 ZZ2540 -- mark 6382, -110 /be scut -+007402 777442 ZZ2541=ZZ2541+ZZ2541 -+007402 777104 ZZ2541=ZZ2541+ZZ2541 -+007402 776210 ZZ2541=ZZ2541+ZZ2541 -+007402 774420 ZZ2541=ZZ2541+ZZ2541 -+007402 771040 ZZ2541=ZZ2541+ZZ2541 -+007402 762100 ZZ2541=ZZ2541+ZZ2541 -+007402 744200 ZZ2541=ZZ2541+ZZ2541 -+007402 710400 ZZ2541=ZZ2541+ZZ2541 -+007402 003422 0 8192 -ZZ1541 -+007403 710400 0 ZZ2541 -- mark 6386, 411 /111 herc -+007404 001466 ZZ2542=ZZ2542+ZZ2542 -+007404 003154 ZZ2542=ZZ2542+ZZ2542 -+007404 006330 ZZ2542=ZZ2542+ZZ2542 -+007404 014660 ZZ2542=ZZ2542+ZZ2542 -+007404 031540 ZZ2542=ZZ2542+ZZ2542 -+007404 063300 ZZ2542=ZZ2542+ZZ2542 -+007404 146600 ZZ2542=ZZ2542+ZZ2542 -+007404 315400 ZZ2542=ZZ2542+ZZ2542 -+007404 003416 0 8192 -ZZ1542 -+007405 315400 0 ZZ2542 -- mark 6436, 93 /63 serp -+007406 000272 ZZ2543=ZZ2543+ZZ2543 -+007406 000564 ZZ2543=ZZ2543+ZZ2543 -+007406 001350 ZZ2543=ZZ2543+ZZ2543 -+007406 002720 ZZ2543=ZZ2543+ZZ2543 -+007406 005640 ZZ2543=ZZ2543+ZZ2543 -+007406 013500 ZZ2543=ZZ2543+ZZ2543 -+007406 027200 ZZ2543=ZZ2543+ZZ2543 -+007406 056400 ZZ2543=ZZ2543+ZZ2543 -+007406 003334 0 8192 -ZZ1543 -+007407 056400 0 ZZ2543 -- mark 6457, 340 /13 aqil -+007410 001250 ZZ2544=ZZ2544+ZZ2544 -+007410 002520 ZZ2544=ZZ2544+ZZ2544 -+007410 005240 ZZ2544=ZZ2544+ZZ2544 -+007410 012500 ZZ2544=ZZ2544+ZZ2544 -+007410 025200 ZZ2544=ZZ2544+ZZ2544 -+007410 052400 ZZ2544=ZZ2544+ZZ2544 -+007410 125000 ZZ2544=ZZ2544+ZZ2544 -+007410 252000 ZZ2544=ZZ2544+ZZ2544 -+007410 003307 0 8192 -ZZ1544 -+007411 252000 0 ZZ2544 -- mark 6465, -134 /12 aqil -+007412 777362 ZZ2545=ZZ2545+ZZ2545 -+007412 776744 ZZ2545=ZZ2545+ZZ2545 -+007412 775710 ZZ2545=ZZ2545+ZZ2545 -+007412 773620 ZZ2545=ZZ2545+ZZ2545 -+007412 767440 ZZ2545=ZZ2545+ZZ2545 -+007412 757100 ZZ2545=ZZ2545+ZZ2545 -+007412 736200 ZZ2545=ZZ2545+ZZ2545 -+007412 674400 ZZ2545=ZZ2545+ZZ2545 -+007412 003277 0 8192 -ZZ1545 -+007413 674400 0 ZZ2545 -- mark 6478, -498 /39 sgtr -+007414 776032 ZZ2546=ZZ2546+ZZ2546 -+007414 774064 ZZ2546=ZZ2546+ZZ2546 -+007414 770150 ZZ2546=ZZ2546+ZZ2546 -+007414 760320 ZZ2546=ZZ2546+ZZ2546 -+007414 740640 ZZ2546=ZZ2546+ZZ2546 -+007414 701500 ZZ2546=ZZ2546+ZZ2546 -+007414 603200 ZZ2546=ZZ2546+ZZ2546 -+007414 406400 ZZ2546=ZZ2546+ZZ2546 -+007414 003262 0 8192 -ZZ1546 -+007415 406400 0 ZZ2546 -- mark 6553, 483 / 1 vulp -+007416 001706 ZZ2547=ZZ2547+ZZ2547 -+007416 003614 ZZ2547=ZZ2547+ZZ2547 -+007416 007430 ZZ2547=ZZ2547+ZZ2547 -+007416 017060 ZZ2547=ZZ2547+ZZ2547 -+007416 036140 ZZ2547=ZZ2547+ZZ2547 -+007416 074300 ZZ2547=ZZ2547+ZZ2547 -+007416 170600 ZZ2547=ZZ2547+ZZ2547 -+007416 361400 ZZ2547=ZZ2547+ZZ2547 -+007416 003147 0 8192 -ZZ1547 -+007417 361400 0 ZZ2547 -- mark 6576, -410 /44 sgtr -+007420 776312 ZZ2548=ZZ2548+ZZ2548 -+007420 774624 ZZ2548=ZZ2548+ZZ2548 -+007420 771450 ZZ2548=ZZ2548+ZZ2548 -+007420 763120 ZZ2548=ZZ2548+ZZ2548 -+007420 746240 ZZ2548=ZZ2548+ZZ2548 -+007420 714500 ZZ2548=ZZ2548+ZZ2548 -+007420 631200 ZZ2548=ZZ2548+ZZ2548 -+007420 462400 ZZ2548=ZZ2548+ZZ2548 -+007420 003120 0 8192 -ZZ1548 -+007421 462400 0 ZZ2548 -- mark 6576, -368 /46 sgtr -+007422 776436 ZZ2549=ZZ2549+ZZ2549 -+007422 775074 ZZ2549=ZZ2549+ZZ2549 -+007422 772170 ZZ2549=ZZ2549+ZZ2549 -+007422 764360 ZZ2549=ZZ2549+ZZ2549 -+007422 750740 ZZ2549=ZZ2549+ZZ2549 -+007422 721700 ZZ2549=ZZ2549+ZZ2549 -+007422 643600 ZZ2549=ZZ2549+ZZ2549 -+007422 507400 ZZ2549=ZZ2549+ZZ2549 -+007422 003120 0 8192 -ZZ1549 -+007423 507400 0 ZZ2549 -- mark 6607, 3 /32 aqil -+007424 000006 ZZ2550=ZZ2550+ZZ2550 -+007424 000014 ZZ2550=ZZ2550+ZZ2550 -+007424 000030 ZZ2550=ZZ2550+ZZ2550 -+007424 000060 ZZ2550=ZZ2550+ZZ2550 -+007424 000140 ZZ2550=ZZ2550+ZZ2550 -+007424 000300 ZZ2550=ZZ2550+ZZ2550 -+007424 000600 ZZ2550=ZZ2550+ZZ2550 -+007424 001400 ZZ2550=ZZ2550+ZZ2550 -+007424 003061 0 8192 -ZZ1550 -+007425 001400 0 ZZ2550 -- mark 6651, 163 /38 aqil -+007426 000506 ZZ2551=ZZ2551+ZZ2551 -+007426 001214 ZZ2551=ZZ2551+ZZ2551 -+007426 002430 ZZ2551=ZZ2551+ZZ2551 -+007426 005060 ZZ2551=ZZ2551+ZZ2551 -+007426 012140 ZZ2551=ZZ2551+ZZ2551 -+007426 024300 ZZ2551=ZZ2551+ZZ2551 -+007426 050600 ZZ2551=ZZ2551+ZZ2551 -+007426 121400 ZZ2551=ZZ2551+ZZ2551 -+007426 003005 0 8192 -ZZ1551 -+007427 121400 0 ZZ2551 -- mark 6657, 445 / 9 vulp -+007430 001572 ZZ2552=ZZ2552+ZZ2552 -+007430 003364 ZZ2552=ZZ2552+ZZ2552 -+007430 006750 ZZ2552=ZZ2552+ZZ2552 -+007430 015720 ZZ2552=ZZ2552+ZZ2552 -+007430 033640 ZZ2552=ZZ2552+ZZ2552 -+007430 067500 ZZ2552=ZZ2552+ZZ2552 -+007430 157200 ZZ2552=ZZ2552+ZZ2552 -+007430 336400 ZZ2552=ZZ2552+ZZ2552 -+007430 002777 0 8192 -ZZ1552 -+007431 336400 0 ZZ2552 -- mark 6665, -35 /41 aqil -+007432 777670 ZZ2553=ZZ2553+ZZ2553 -+007432 777560 ZZ2553=ZZ2553+ZZ2553 -+007432 777340 ZZ2553=ZZ2553+ZZ2553 -+007432 776700 ZZ2553=ZZ2553+ZZ2553 -+007432 775600 ZZ2553=ZZ2553+ZZ2553 -+007432 773400 ZZ2553=ZZ2553+ZZ2553 -+007432 767000 ZZ2553=ZZ2553+ZZ2553 -+007432 756000 ZZ2553=ZZ2553+ZZ2553 -+007432 002767 0 8192 -ZZ1553 -+007433 756000 0 ZZ2553 -- mark 6688, 405 / 5 sgte -+007434 001452 ZZ2554=ZZ2554+ZZ2554 -+007434 003124 ZZ2554=ZZ2554+ZZ2554 -+007434 006250 ZZ2554=ZZ2554+ZZ2554 -+007434 014520 ZZ2554=ZZ2554+ZZ2554 -+007434 031240 ZZ2554=ZZ2554+ZZ2554 -+007434 062500 ZZ2554=ZZ2554+ZZ2554 -+007434 145200 ZZ2554=ZZ2554+ZZ2554 -+007434 312400 ZZ2554=ZZ2554+ZZ2554 -+007434 002740 0 8192 -ZZ1554 -+007435 312400 0 ZZ2554 -- mark 6693, 393 / 6 sgte -+007436 001422 ZZ2555=ZZ2555+ZZ2555 -+007436 003044 ZZ2555=ZZ2555+ZZ2555 -+007436 006110 ZZ2555=ZZ2555+ZZ2555 -+007436 014220 ZZ2555=ZZ2555+ZZ2555 -+007436 030440 ZZ2555=ZZ2555+ZZ2555 -+007436 061100 ZZ2555=ZZ2555+ZZ2555 -+007436 142200 ZZ2555=ZZ2555+ZZ2555 -+007436 304400 ZZ2555=ZZ2555+ZZ2555 -+007436 002733 0 8192 -ZZ1555 -+007437 304400 0 ZZ2555 -- mark 6730, 416 / 7 sgte -+007440 001500 ZZ2556=ZZ2556+ZZ2556 -+007440 003200 ZZ2556=ZZ2556+ZZ2556 -+007440 006400 ZZ2556=ZZ2556+ZZ2556 -+007440 015000 ZZ2556=ZZ2556+ZZ2556 -+007440 032000 ZZ2556=ZZ2556+ZZ2556 -+007440 064000 ZZ2556=ZZ2556+ZZ2556 -+007440 150000 ZZ2556=ZZ2556+ZZ2556 -+007440 320000 ZZ2556=ZZ2556+ZZ2556 -+007440 002666 0 8192 -ZZ1556 -+007441 320000 0 ZZ2556 -- mark 6739, 430 / 8 sgte -+007442 001534 ZZ2557=ZZ2557+ZZ2557 -+007442 003270 ZZ2557=ZZ2557+ZZ2557 -+007442 006560 ZZ2557=ZZ2557+ZZ2557 -+007442 015340 ZZ2557=ZZ2557+ZZ2557 -+007442 032700 ZZ2557=ZZ2557+ZZ2557 -+007442 065600 ZZ2557=ZZ2557+ZZ2557 -+007442 153400 ZZ2557=ZZ2557+ZZ2557 -+007442 327000 ZZ2557=ZZ2557+ZZ2557 -+007442 002655 0 8192 -ZZ1557 -+007443 327000 0 ZZ2557 -- mark 6755, 17 /55 aqil -+007444 000042 ZZ2558=ZZ2558+ZZ2558 -+007444 000104 ZZ2558=ZZ2558+ZZ2558 -+007444 000210 ZZ2558=ZZ2558+ZZ2558 -+007444 000420 ZZ2558=ZZ2558+ZZ2558 -+007444 001040 ZZ2558=ZZ2558+ZZ2558 -+007444 002100 ZZ2558=ZZ2558+ZZ2558 -+007444 004200 ZZ2558=ZZ2558+ZZ2558 -+007444 010400 ZZ2558=ZZ2558+ZZ2558 -+007444 002635 0 8192 -ZZ1558 -+007445 010400 0 ZZ2558 -- mark 6766, 187 /59 aqil -+007446 000566 ZZ2559=ZZ2559+ZZ2559 -+007446 001354 ZZ2559=ZZ2559+ZZ2559 -+007446 002730 ZZ2559=ZZ2559+ZZ2559 -+007446 005660 ZZ2559=ZZ2559+ZZ2559 -+007446 013540 ZZ2559=ZZ2559+ZZ2559 -+007446 027300 ZZ2559=ZZ2559+ZZ2559 -+007446 056600 ZZ2559=ZZ2559+ZZ2559 -+007446 135400 ZZ2559=ZZ2559+ZZ2559 -+007446 002622 0 8192 -ZZ1559 -+007447 135400 0 ZZ2559 -- mark 6772, 140 /60 aqil -+007450 000430 ZZ2560=ZZ2560+ZZ2560 -+007450 001060 ZZ2560=ZZ2560+ZZ2560 -+007450 002140 ZZ2560=ZZ2560+ZZ2560 -+007450 004300 ZZ2560=ZZ2560+ZZ2560 -+007450 010600 ZZ2560=ZZ2560+ZZ2560 -+007450 021400 ZZ2560=ZZ2560+ZZ2560 -+007450 043000 ZZ2560=ZZ2560+ZZ2560 -+007450 106000 ZZ2560=ZZ2560+ZZ2560 -+007450 002614 0 8192 -ZZ1560 -+007451 106000 0 ZZ2560 -- mark 6882, 339 /67 aqil -+007452 001246 ZZ2561=ZZ2561+ZZ2561 -+007452 002514 ZZ2561=ZZ2561+ZZ2561 -+007452 005230 ZZ2561=ZZ2561+ZZ2561 -+007452 012460 ZZ2561=ZZ2561+ZZ2561 -+007452 025140 ZZ2561=ZZ2561+ZZ2561 -+007452 052300 ZZ2561=ZZ2561+ZZ2561 -+007452 124600 ZZ2561=ZZ2561+ZZ2561 -+007452 251400 ZZ2561=ZZ2561+ZZ2561 -+007452 002436 0 8192 -ZZ1561 -+007453 251400 0 ZZ2561 -- mark 6896, -292 / 5 capr -+007454 776666 ZZ2562=ZZ2562+ZZ2562 -+007454 775554 ZZ2562=ZZ2562+ZZ2562 -+007454 773330 ZZ2562=ZZ2562+ZZ2562 -+007454 766660 ZZ2562=ZZ2562+ZZ2562 -+007454 755540 ZZ2562=ZZ2562+ZZ2562 -+007454 733300 ZZ2562=ZZ2562+ZZ2562 -+007454 666600 ZZ2562=ZZ2562+ZZ2562 -+007454 555400 ZZ2562=ZZ2562+ZZ2562 -+007454 002420 0 8192 -ZZ1562 -+007455 555400 0 ZZ2562 -- mark 6898, -292 / 6 capr -+007456 776666 ZZ2563=ZZ2563+ZZ2563 -+007456 775554 ZZ2563=ZZ2563+ZZ2563 -+007456 773330 ZZ2563=ZZ2563+ZZ2563 -+007456 766660 ZZ2563=ZZ2563+ZZ2563 -+007456 755540 ZZ2563=ZZ2563+ZZ2563 -+007456 733300 ZZ2563=ZZ2563+ZZ2563 -+007456 666600 ZZ2563=ZZ2563+ZZ2563 -+007456 555400 ZZ2563=ZZ2563+ZZ2563 -+007456 002416 0 8192 -ZZ1563 -+007457 555400 0 ZZ2563 -- mark 6913, -297 / 8 capr -+007460 776654 ZZ2564=ZZ2564+ZZ2564 -+007460 775530 ZZ2564=ZZ2564+ZZ2564 -+007460 773260 ZZ2564=ZZ2564+ZZ2564 -+007460 766540 ZZ2564=ZZ2564+ZZ2564 -+007460 755300 ZZ2564=ZZ2564+ZZ2564 -+007460 732600 ZZ2564=ZZ2564+ZZ2564 -+007460 665400 ZZ2564=ZZ2564+ZZ2564 -+007460 553000 ZZ2564=ZZ2564+ZZ2564 -+007460 002377 0 8192 -ZZ1564 -+007461 553000 0 ZZ2564 -- mark 6958, -413 /11 capr -+007462 776304 ZZ2565=ZZ2565+ZZ2565 -+007462 774610 ZZ2565=ZZ2565+ZZ2565 -+007462 771420 ZZ2565=ZZ2565+ZZ2565 -+007462 763040 ZZ2565=ZZ2565+ZZ2565 -+007462 746100 ZZ2565=ZZ2565+ZZ2565 -+007462 714200 ZZ2565=ZZ2565+ZZ2565 -+007462 630400 ZZ2565=ZZ2565+ZZ2565 -+007462 461000 ZZ2565=ZZ2565+ZZ2565 -+007462 002322 0 8192 -ZZ1565 -+007463 461000 0 ZZ2565 -- mark 6988, 250 / 2 dlph -+007464 000764 ZZ2566=ZZ2566+ZZ2566 -+007464 001750 ZZ2566=ZZ2566+ZZ2566 -+007464 003720 ZZ2566=ZZ2566+ZZ2566 -+007464 007640 ZZ2566=ZZ2566+ZZ2566 -+007464 017500 ZZ2566=ZZ2566+ZZ2566 -+007464 037200 ZZ2566=ZZ2566+ZZ2566 -+007464 076400 ZZ2566=ZZ2566+ZZ2566 -+007464 175000 ZZ2566=ZZ2566+ZZ2566 -+007464 002264 0 8192 -ZZ1566 -+007465 175000 0 ZZ2566 -- mark 7001, 326 / 4 dlph -+007466 001214 ZZ2567=ZZ2567+ZZ2567 -+007466 002430 ZZ2567=ZZ2567+ZZ2567 -+007466 005060 ZZ2567=ZZ2567+ZZ2567 -+007466 012140 ZZ2567=ZZ2567+ZZ2567 -+007466 024300 ZZ2567=ZZ2567+ZZ2567 -+007466 050600 ZZ2567=ZZ2567+ZZ2567 -+007466 121400 ZZ2567=ZZ2567+ZZ2567 -+007466 243000 ZZ2567=ZZ2567+ZZ2567 -+007466 002247 0 8192 -ZZ1567 -+007467 243000 0 ZZ2567 -- mark 7015, -33 /71 aqil -+007470 777674 ZZ2568=ZZ2568+ZZ2568 -+007470 777570 ZZ2568=ZZ2568+ZZ2568 -+007470 777360 ZZ2568=ZZ2568+ZZ2568 -+007470 776740 ZZ2568=ZZ2568+ZZ2568 -+007470 775700 ZZ2568=ZZ2568+ZZ2568 -+007470 773600 ZZ2568=ZZ2568+ZZ2568 -+007470 767400 ZZ2568=ZZ2568+ZZ2568 -+007470 757000 ZZ2568=ZZ2568+ZZ2568 -+007470 002231 0 8192 -ZZ1568 -+007471 757000 0 ZZ2568 -- mark 7020, 475 /29 vulp -+007472 001666 ZZ2569=ZZ2569+ZZ2569 -+007472 003554 ZZ2569=ZZ2569+ZZ2569 -+007472 007330 ZZ2569=ZZ2569+ZZ2569 -+007472 016660 ZZ2569=ZZ2569+ZZ2569 -+007472 035540 ZZ2569=ZZ2569+ZZ2569 -+007472 073300 ZZ2569=ZZ2569+ZZ2569 -+007472 166600 ZZ2569=ZZ2569+ZZ2569 -+007472 355400 ZZ2569=ZZ2569+ZZ2569 -+007472 002224 0 8192 -ZZ1569 -+007473 355400 0 ZZ2569 -- mark 7026, 354 / 9 dlph -+007474 001304 ZZ2570=ZZ2570+ZZ2570 -+007474 002610 ZZ2570=ZZ2570+ZZ2570 -+007474 005420 ZZ2570=ZZ2570+ZZ2570 -+007474 013040 ZZ2570=ZZ2570+ZZ2570 -+007474 026100 ZZ2570=ZZ2570+ZZ2570 -+007474 054200 ZZ2570=ZZ2570+ZZ2570 -+007474 130400 ZZ2570=ZZ2570+ZZ2570 -+007474 261000 ZZ2570=ZZ2570+ZZ2570 -+007474 002216 0 8192 -ZZ1570 -+007475 261000 0 ZZ2570 -- mark 7047, 335 /11 dlph -+007476 001236 ZZ2571=ZZ2571+ZZ2571 -+007476 002474 ZZ2571=ZZ2571+ZZ2571 -+007476 005170 ZZ2571=ZZ2571+ZZ2571 -+007476 012360 ZZ2571=ZZ2571+ZZ2571 -+007476 024740 ZZ2571=ZZ2571+ZZ2571 -+007476 051700 ZZ2571=ZZ2571+ZZ2571 -+007476 123600 ZZ2571=ZZ2571+ZZ2571 -+007476 247400 ZZ2571=ZZ2571+ZZ2571 -+007476 002171 0 8192 -ZZ1571 -+007477 247400 0 ZZ2571 -- mark 7066, 359 /12 dlph -+007500 001316 ZZ2572=ZZ2572+ZZ2572 -+007500 002634 ZZ2572=ZZ2572+ZZ2572 -+007500 005470 ZZ2572=ZZ2572+ZZ2572 -+007500 013160 ZZ2572=ZZ2572+ZZ2572 -+007500 026340 ZZ2572=ZZ2572+ZZ2572 -+007500 054700 ZZ2572=ZZ2572+ZZ2572 -+007500 131600 ZZ2572=ZZ2572+ZZ2572 -+007500 263400 ZZ2572=ZZ2572+ZZ2572 -+007500 002146 0 8192 -ZZ1572 -+007501 263400 0 ZZ2572 -- mark 7067, -225 / 2 aqar -+007502 777074 ZZ2573=ZZ2573+ZZ2573 -+007502 776170 ZZ2573=ZZ2573+ZZ2573 -+007502 774360 ZZ2573=ZZ2573+ZZ2573 -+007502 770740 ZZ2573=ZZ2573+ZZ2573 -+007502 761700 ZZ2573=ZZ2573+ZZ2573 -+007502 743600 ZZ2573=ZZ2573+ZZ2573 -+007502 707400 ZZ2573=ZZ2573+ZZ2573 -+007502 617000 ZZ2573=ZZ2573+ZZ2573 -+007502 002145 0 8192 -ZZ1573 -+007503 617000 0 ZZ2573 -- mark 7068, -123 / 3 aqar -+007504 777410 ZZ2574=ZZ2574+ZZ2574 -+007504 777020 ZZ2574=ZZ2574+ZZ2574 -+007504 776040 ZZ2574=ZZ2574+ZZ2574 -+007504 774100 ZZ2574=ZZ2574+ZZ2574 -+007504 770200 ZZ2574=ZZ2574+ZZ2574 -+007504 760400 ZZ2574=ZZ2574+ZZ2574 -+007504 741000 ZZ2574=ZZ2574+ZZ2574 -+007504 702000 ZZ2574=ZZ2574+ZZ2574 -+007504 002144 0 8192 -ZZ1574 -+007505 702000 0 ZZ2574 -- mark 7096, -213 / 6 aqar -+007506 777124 ZZ2575=ZZ2575+ZZ2575 -+007506 776250 ZZ2575=ZZ2575+ZZ2575 -+007506 774520 ZZ2575=ZZ2575+ZZ2575 -+007506 771240 ZZ2575=ZZ2575+ZZ2575 -+007506 762500 ZZ2575=ZZ2575+ZZ2575 -+007506 745200 ZZ2575=ZZ2575+ZZ2575 -+007506 712400 ZZ2575=ZZ2575+ZZ2575 -+007506 625000 ZZ2575=ZZ2575+ZZ2575 -+007506 002110 0 8192 -ZZ1575 -+007507 625000 0 ZZ2575 -- mark 7161, -461 /22 capr -+007510 776144 ZZ2576=ZZ2576+ZZ2576 -+007510 774310 ZZ2576=ZZ2576+ZZ2576 -+007510 770620 ZZ2576=ZZ2576+ZZ2576 -+007510 761440 ZZ2576=ZZ2576+ZZ2576 -+007510 743100 ZZ2576=ZZ2576+ZZ2576 -+007510 706200 ZZ2576=ZZ2576+ZZ2576 -+007510 614400 ZZ2576=ZZ2576+ZZ2576 -+007510 431000 ZZ2576=ZZ2576+ZZ2576 -+007510 002007 0 8192 -ZZ1576 -+007511 431000 0 ZZ2576 -- mark 7170, -401 /23 capr -+007512 776334 ZZ2577=ZZ2577+ZZ2577 -+007512 774670 ZZ2577=ZZ2577+ZZ2577 -+007512 771560 ZZ2577=ZZ2577+ZZ2577 -+007512 763340 ZZ2577=ZZ2577+ZZ2577 -+007512 746700 ZZ2577=ZZ2577+ZZ2577 -+007512 715600 ZZ2577=ZZ2577+ZZ2577 -+007512 633400 ZZ2577=ZZ2577+ZZ2577 -+007512 467000 ZZ2577=ZZ2577+ZZ2577 -+007512 001776 0 8192 -ZZ1577 -+007513 467000 0 ZZ2577 -- mark 7192, -268 /13 capr -+007514 776746 ZZ2578=ZZ2578+ZZ2578 -+007514 775714 ZZ2578=ZZ2578+ZZ2578 -+007514 773630 ZZ2578=ZZ2578+ZZ2578 -+007514 767460 ZZ2578=ZZ2578+ZZ2578 -+007514 757140 ZZ2578=ZZ2578+ZZ2578 -+007514 736300 ZZ2578=ZZ2578+ZZ2578 -+007514 674600 ZZ2578=ZZ2578+ZZ2578 -+007514 571400 ZZ2578=ZZ2578+ZZ2578 -+007514 001750 0 8192 -ZZ1578 -+007515 571400 0 ZZ2578 -- mark 7199, 222 / 5 equl -+007516 000674 ZZ2579=ZZ2579+ZZ2579 -+007516 001570 ZZ2579=ZZ2579+ZZ2579 -+007516 003360 ZZ2579=ZZ2579+ZZ2579 -+007516 006740 ZZ2579=ZZ2579+ZZ2579 -+007516 015700 ZZ2579=ZZ2579+ZZ2579 -+007516 033600 ZZ2579=ZZ2579+ZZ2579 -+007516 067400 ZZ2579=ZZ2579+ZZ2579 -+007516 157000 ZZ2579=ZZ2579+ZZ2579 -+007516 001741 0 8192 -ZZ1579 -+007517 157000 0 ZZ2579 -- mark 7223, 219 / 7 equl -+007520 000666 ZZ2580=ZZ2580+ZZ2580 -+007520 001554 ZZ2580=ZZ2580+ZZ2580 -+007520 003330 ZZ2580=ZZ2580+ZZ2580 -+007520 006660 ZZ2580=ZZ2580+ZZ2580 -+007520 015540 ZZ2580=ZZ2580+ZZ2580 -+007520 033300 ZZ2580=ZZ2580+ZZ2580 -+007520 066600 ZZ2580=ZZ2580+ZZ2580 -+007520 155400 ZZ2580=ZZ2580+ZZ2580 -+007520 001711 0 8192 -ZZ1580 -+007521 155400 0 ZZ2580 -- mark 7230, 110 / 8 equl -+007522 000334 ZZ2581=ZZ2581+ZZ2581 -+007522 000670 ZZ2581=ZZ2581+ZZ2581 -+007522 001560 ZZ2581=ZZ2581+ZZ2581 -+007522 003340 ZZ2581=ZZ2581+ZZ2581 -+007522 006700 ZZ2581=ZZ2581+ZZ2581 -+007522 015600 ZZ2581=ZZ2581+ZZ2581 -+007522 033400 ZZ2581=ZZ2581+ZZ2581 -+007522 067000 ZZ2581=ZZ2581+ZZ2581 -+007522 001702 0 8192 -ZZ1581 -+007523 067000 0 ZZ2581 -- mark 7263, -393 /32 capr -+007524 776354 ZZ2582=ZZ2582+ZZ2582 -+007524 774730 ZZ2582=ZZ2582+ZZ2582 -+007524 771660 ZZ2582=ZZ2582+ZZ2582 -+007524 763540 ZZ2582=ZZ2582+ZZ2582 -+007524 747300 ZZ2582=ZZ2582+ZZ2582 -+007524 716600 ZZ2582=ZZ2582+ZZ2582 -+007524 635400 ZZ2582=ZZ2582+ZZ2582 -+007524 473000 ZZ2582=ZZ2582+ZZ2582 -+007524 001641 0 8192 -ZZ1582 -+007525 473000 0 ZZ2582 -- mark 7267, 441 / 1 pegs -+007526 001562 ZZ2583=ZZ2583+ZZ2583 -+007526 003344 ZZ2583=ZZ2583+ZZ2583 -+007526 006710 ZZ2583=ZZ2583+ZZ2583 -+007526 015620 ZZ2583=ZZ2583+ZZ2583 -+007526 033440 ZZ2583=ZZ2583+ZZ2583 -+007526 067100 ZZ2583=ZZ2583+ZZ2583 -+007526 156200 ZZ2583=ZZ2583+ZZ2583 -+007526 334400 ZZ2583=ZZ2583+ZZ2583 -+007526 001635 0 8192 -ZZ1583 -+007527 334400 0 ZZ2583 -- mark 7299, -506 /36 capr -+007530 776012 ZZ2584=ZZ2584+ZZ2584 -+007530 774024 ZZ2584=ZZ2584+ZZ2584 -+007530 770050 ZZ2584=ZZ2584+ZZ2584 -+007530 760120 ZZ2584=ZZ2584+ZZ2584 -+007530 740240 ZZ2584=ZZ2584+ZZ2584 -+007530 700500 ZZ2584=ZZ2584+ZZ2584 -+007530 601200 ZZ2584=ZZ2584+ZZ2584 -+007530 402400 ZZ2584=ZZ2584+ZZ2584 -+007530 001575 0 8192 -ZZ1584 -+007531 402400 0 ZZ2584 -- mark 7347, -453 /39 capr -+007532 776164 ZZ2585=ZZ2585+ZZ2585 -+007532 774350 ZZ2585=ZZ2585+ZZ2585 -+007532 770720 ZZ2585=ZZ2585+ZZ2585 -+007532 761640 ZZ2585=ZZ2585+ZZ2585 -+007532 743500 ZZ2585=ZZ2585+ZZ2585 -+007532 707200 ZZ2585=ZZ2585+ZZ2585 -+007532 616400 ZZ2585=ZZ2585+ZZ2585 -+007532 435000 ZZ2585=ZZ2585+ZZ2585 -+007532 001515 0 8192 -ZZ1585 -+007533 435000 0 ZZ2585 -- mark 7353, -189 /23 aqar -+007534 777204 ZZ2586=ZZ2586+ZZ2586 -+007534 776410 ZZ2586=ZZ2586+ZZ2586 -+007534 775020 ZZ2586=ZZ2586+ZZ2586 -+007534 772040 ZZ2586=ZZ2586+ZZ2586 -+007534 764100 ZZ2586=ZZ2586+ZZ2586 -+007534 750200 ZZ2586=ZZ2586+ZZ2586 -+007534 720400 ZZ2586=ZZ2586+ZZ2586 -+007534 641000 ZZ2586=ZZ2586+ZZ2586 -+007534 001507 0 8192 -ZZ1586 -+007535 641000 0 ZZ2586 -- mark 7365, -390 /40 capr -+007536 776362 ZZ2587=ZZ2587+ZZ2587 -+007536 774744 ZZ2587=ZZ2587+ZZ2587 -+007536 771710 ZZ2587=ZZ2587+ZZ2587 -+007536 763620 ZZ2587=ZZ2587+ZZ2587 -+007536 747440 ZZ2587=ZZ2587+ZZ2587 -+007536 717100 ZZ2587=ZZ2587+ZZ2587 -+007536 636200 ZZ2587=ZZ2587+ZZ2587 -+007536 474400 ZZ2587=ZZ2587+ZZ2587 -+007536 001473 0 8192 -ZZ1587 -+007537 474400 0 ZZ2587 -- mark 7379, -440 /43 capr -+007540 776216 ZZ2588=ZZ2588+ZZ2588 -+007540 774434 ZZ2588=ZZ2588+ZZ2588 -+007540 771070 ZZ2588=ZZ2588+ZZ2588 -+007540 762160 ZZ2588=ZZ2588+ZZ2588 -+007540 744340 ZZ2588=ZZ2588+ZZ2588 -+007540 710700 ZZ2588=ZZ2588+ZZ2588 -+007540 621600 ZZ2588=ZZ2588+ZZ2588 -+007540 443400 ZZ2588=ZZ2588+ZZ2588 -+007540 001455 0 8192 -ZZ1588 -+007541 443400 0 ZZ2588 -- mark 7394, 384 / 9 pegs -+007542 001400 ZZ2589=ZZ2589+ZZ2589 -+007542 003000 ZZ2589=ZZ2589+ZZ2589 -+007542 006000 ZZ2589=ZZ2589+ZZ2589 -+007542 014000 ZZ2589=ZZ2589+ZZ2589 -+007542 030000 ZZ2589=ZZ2589+ZZ2589 -+007542 060000 ZZ2589=ZZ2589+ZZ2589 -+007542 140000 ZZ2589=ZZ2589+ZZ2589 -+007542 300000 ZZ2589=ZZ2589+ZZ2589 -+007542 001436 0 8192 -ZZ1589 -+007543 300000 0 ZZ2589 -- mark 7499, -60 /31 aquar -+007544 777606 ZZ2590=ZZ2590+ZZ2590 -+007544 777414 ZZ2590=ZZ2590+ZZ2590 -+007544 777030 ZZ2590=ZZ2590+ZZ2590 -+007544 776060 ZZ2590=ZZ2590+ZZ2590 -+007544 774140 ZZ2590=ZZ2590+ZZ2590 -+007544 770300 ZZ2590=ZZ2590+ZZ2590 -+007544 760600 ZZ2590=ZZ2590+ZZ2590 -+007544 741400 ZZ2590=ZZ2590+ZZ2590 -+007544 001265 0 8192 -ZZ1590 -+007545 741400 0 ZZ2590 -- mark 7513, 104 /22 pegs -+007546 000320 ZZ2591=ZZ2591+ZZ2591 -+007546 000640 ZZ2591=ZZ2591+ZZ2591 -+007546 001500 ZZ2591=ZZ2591+ZZ2591 -+007546 003200 ZZ2591=ZZ2591+ZZ2591 -+007546 006400 ZZ2591=ZZ2591+ZZ2591 -+007546 015000 ZZ2591=ZZ2591+ZZ2591 -+007546 032000 ZZ2591=ZZ2591+ZZ2591 -+007546 064000 ZZ2591=ZZ2591+ZZ2591 -+007546 001247 0 8192 -ZZ1591 -+007547 064000 0 ZZ2591 -- mark 7515, -327 /33 aqar -+007550 776560 ZZ2592=ZZ2592+ZZ2592 -+007550 775340 ZZ2592=ZZ2592+ZZ2592 -+007550 772700 ZZ2592=ZZ2592+ZZ2592 -+007550 765600 ZZ2592=ZZ2592+ZZ2592 -+007550 753400 ZZ2592=ZZ2592+ZZ2592 -+007550 727000 ZZ2592=ZZ2592+ZZ2592 -+007550 656000 ZZ2592=ZZ2592+ZZ2592 -+007550 534000 ZZ2592=ZZ2592+ZZ2592 -+007550 001245 0 8192 -ZZ1592 -+007551 534000 0 ZZ2592 -- mark 7575, -189 /43 aqar -+007552 777204 ZZ2593=ZZ2593+ZZ2593 -+007552 776410 ZZ2593=ZZ2593+ZZ2593 -+007552 775020 ZZ2593=ZZ2593+ZZ2593 -+007552 772040 ZZ2593=ZZ2593+ZZ2593 -+007552 764100 ZZ2593=ZZ2593+ZZ2593 -+007552 750200 ZZ2593=ZZ2593+ZZ2593 -+007552 720400 ZZ2593=ZZ2593+ZZ2593 -+007552 641000 ZZ2593=ZZ2593+ZZ2593 -+007552 001151 0 8192 -ZZ1593 -+007553 641000 0 ZZ2593 -- mark 7603, -43 /48 aqar -+007554 777650 ZZ2594=ZZ2594+ZZ2594 -+007554 777520 ZZ2594=ZZ2594+ZZ2594 -+007554 777240 ZZ2594=ZZ2594+ZZ2594 -+007554 776500 ZZ2594=ZZ2594+ZZ2594 -+007554 775200 ZZ2594=ZZ2594+ZZ2594 -+007554 772400 ZZ2594=ZZ2594+ZZ2594 -+007554 765000 ZZ2594=ZZ2594+ZZ2594 -+007554 752000 ZZ2594=ZZ2594+ZZ2594 -+007554 001115 0 8192 -ZZ1594 -+007555 752000 0 ZZ2594 -- mark 7604, 266 /31 pegs -+007556 001024 ZZ2595=ZZ2595+ZZ2595 -+007556 002050 ZZ2595=ZZ2595+ZZ2595 -+007556 004120 ZZ2595=ZZ2595+ZZ2595 -+007556 010240 ZZ2595=ZZ2595+ZZ2595 -+007556 020500 ZZ2595=ZZ2595+ZZ2595 -+007556 041200 ZZ2595=ZZ2595+ZZ2595 -+007556 102400 ZZ2595=ZZ2595+ZZ2595 -+007556 205000 ZZ2595=ZZ2595+ZZ2595 -+007556 001114 0 8192 -ZZ1595 -+007557 205000 0 ZZ2595 -- mark 7624, 20 /52 aquar -+007560 000050 ZZ2596=ZZ2596+ZZ2596 -+007560 000120 ZZ2596=ZZ2596+ZZ2596 -+007560 000240 ZZ2596=ZZ2596+ZZ2596 -+007560 000500 ZZ2596=ZZ2596+ZZ2596 -+007560 001200 ZZ2596=ZZ2596+ZZ2596 -+007560 002400 ZZ2596=ZZ2596+ZZ2596 -+007560 005000 ZZ2596=ZZ2596+ZZ2596 -+007560 012000 ZZ2596=ZZ2596+ZZ2596 -+007560 001070 0 8192 -ZZ1596 -+007561 012000 0 ZZ2596 -- mark 7639, 96 /35 pegs -+007562 000300 ZZ2597=ZZ2597+ZZ2597 -+007562 000600 ZZ2597=ZZ2597+ZZ2597 -+007562 001400 ZZ2597=ZZ2597+ZZ2597 -+007562 003000 ZZ2597=ZZ2597+ZZ2597 -+007562 006000 ZZ2597=ZZ2597+ZZ2597 -+007562 014000 ZZ2597=ZZ2597+ZZ2597 -+007562 030000 ZZ2597=ZZ2597+ZZ2597 -+007562 060000 ZZ2597=ZZ2597+ZZ2597 -+007562 001051 0 8192 -ZZ1597 -+007563 060000 0 ZZ2597 -- mark 7654, -255 /57 aqar -+007564 777000 ZZ2598=ZZ2598+ZZ2598 -+007564 776000 ZZ2598=ZZ2598+ZZ2598 -+007564 774000 ZZ2598=ZZ2598+ZZ2598 -+007564 770000 ZZ2598=ZZ2598+ZZ2598 -+007564 760000 ZZ2598=ZZ2598+ZZ2598 -+007564 740000 ZZ2598=ZZ2598+ZZ2598 -+007564 700000 ZZ2598=ZZ2598+ZZ2598 -+007564 600000 ZZ2598=ZZ2598+ZZ2598 -+007564 001032 0 8192 -ZZ1598 -+007565 600000 0 ZZ2598 -- mark 7681, -14 /62 aqar -+007566 777742 ZZ2599=ZZ2599+ZZ2599 -+007566 777704 ZZ2599=ZZ2599+ZZ2599 -+007566 777610 ZZ2599=ZZ2599+ZZ2599 -+007566 777420 ZZ2599=ZZ2599+ZZ2599 -+007566 777040 ZZ2599=ZZ2599+ZZ2599 -+007566 776100 ZZ2599=ZZ2599+ZZ2599 -+007566 774200 ZZ2599=ZZ2599+ZZ2599 -+007566 770400 ZZ2599=ZZ2599+ZZ2599 -+007566 000777 0 8192 -ZZ1599 -+007567 770400 0 ZZ2599 -- mark 7727, -440 /66 aqar -+007570 776216 ZZ2600=ZZ2600+ZZ2600 -+007570 774434 ZZ2600=ZZ2600+ZZ2600 -+007570 771070 ZZ2600=ZZ2600+ZZ2600 -+007570 762160 ZZ2600=ZZ2600+ZZ2600 -+007570 744340 ZZ2600=ZZ2600+ZZ2600 -+007570 710700 ZZ2600=ZZ2600+ZZ2600 -+007570 621600 ZZ2600=ZZ2600+ZZ2600 -+007570 443400 ZZ2600=ZZ2600+ZZ2600 -+007570 000721 0 8192 -ZZ1600 -+007571 443400 0 ZZ2600 -- mark 7747, 266 /46 pegs -+007572 001024 ZZ2601=ZZ2601+ZZ2601 -+007572 002050 ZZ2601=ZZ2601+ZZ2601 -+007572 004120 ZZ2601=ZZ2601+ZZ2601 -+007572 010240 ZZ2601=ZZ2601+ZZ2601 -+007572 020500 ZZ2601=ZZ2601+ZZ2601 -+007572 041200 ZZ2601=ZZ2601+ZZ2601 -+007572 102400 ZZ2601=ZZ2601+ZZ2601 -+007572 205000 ZZ2601=ZZ2601+ZZ2601 -+007572 000675 0 8192 -ZZ1601 -+007573 205000 0 ZZ2601 -- mark 7761, -321 /71 aqar -+007574 776574 ZZ2602=ZZ2602+ZZ2602 -+007574 775370 ZZ2602=ZZ2602+ZZ2602 -+007574 772760 ZZ2602=ZZ2602+ZZ2602 -+007574 765740 ZZ2602=ZZ2602+ZZ2602 -+007574 753700 ZZ2602=ZZ2602+ZZ2602 -+007574 727600 ZZ2602=ZZ2602+ZZ2602 -+007574 657400 ZZ2602=ZZ2602+ZZ2602 -+007574 537000 ZZ2602=ZZ2602+ZZ2602 -+007574 000657 0 8192 -ZZ1602 -+007575 537000 0 ZZ2602 -- mark 7779, -185 /73 aqar -+007576 777214 ZZ2603=ZZ2603+ZZ2603 -+007576 776430 ZZ2603=ZZ2603+ZZ2603 -+007576 775060 ZZ2603=ZZ2603+ZZ2603 -+007576 772140 ZZ2603=ZZ2603+ZZ2603 -+007576 764300 ZZ2603=ZZ2603+ZZ2603 -+007576 750600 ZZ2603=ZZ2603+ZZ2603 -+007576 721400 ZZ2603=ZZ2603+ZZ2603 -+007576 643000 ZZ2603=ZZ2603+ZZ2603 -+007576 000635 0 8192 -ZZ1603 -+007577 643000 0 ZZ2603 -- mark 7795, 189 /50 pegs -+007600 000572 ZZ2604=ZZ2604+ZZ2604 -+007600 001364 ZZ2604=ZZ2604+ZZ2604 -+007600 002750 ZZ2604=ZZ2604+ZZ2604 -+007600 005720 ZZ2604=ZZ2604+ZZ2604 -+007600 013640 ZZ2604=ZZ2604+ZZ2604 -+007600 027500 ZZ2604=ZZ2604+ZZ2604 -+007600 057200 ZZ2604=ZZ2604+ZZ2604 -+007600 136400 ZZ2604=ZZ2604+ZZ2604 -+007600 000615 0 8192 -ZZ1604 -+007601 136400 0 ZZ2604 -- mark 7844, 75 / 4 pisc -+007602 000226 ZZ2605=ZZ2605+ZZ2605 -+007602 000454 ZZ2605=ZZ2605+ZZ2605 -+007602 001130 ZZ2605=ZZ2605+ZZ2605 -+007602 002260 ZZ2605=ZZ2605+ZZ2605 -+007602 004540 ZZ2605=ZZ2605+ZZ2605 -+007602 011300 ZZ2605=ZZ2605+ZZ2605 -+007602 022600 ZZ2605=ZZ2605+ZZ2605 -+007602 045400 ZZ2605=ZZ2605+ZZ2605 -+007602 000534 0 8192 -ZZ1605 -+007603 045400 0 ZZ2605 -- mark 7862, 202 /55 pegs -+007604 000624 ZZ2606=ZZ2606+ZZ2606 -+007604 001450 ZZ2606=ZZ2606+ZZ2606 -+007604 003120 ZZ2606=ZZ2606+ZZ2606 -+007604 006240 ZZ2606=ZZ2606+ZZ2606 -+007604 014500 ZZ2606=ZZ2606+ZZ2606 -+007604 031200 ZZ2606=ZZ2606+ZZ2606 -+007604 062400 ZZ2606=ZZ2606+ZZ2606 -+007604 145000 ZZ2606=ZZ2606+ZZ2606 -+007604 000512 0 8192 -ZZ1606 -+007605 145000 0 ZZ2606 -- mark 7874, -494 /88 aqar -+007606 776042 ZZ2607=ZZ2607+ZZ2607 -+007606 774104 ZZ2607=ZZ2607+ZZ2607 -+007606 770210 ZZ2607=ZZ2607+ZZ2607 -+007606 760420 ZZ2607=ZZ2607+ZZ2607 -+007606 741040 ZZ2607=ZZ2607+ZZ2607 -+007606 702100 ZZ2607=ZZ2607+ZZ2607 -+007606 604200 ZZ2607=ZZ2607+ZZ2607 -+007606 410400 ZZ2607=ZZ2607+ZZ2607 -+007606 000476 0 8192 -ZZ1607 -+007607 410400 0 ZZ2607 -- mark 7903, -150 /90 aqar -+007610 777322 ZZ2608=ZZ2608+ZZ2608 -+007610 776644 ZZ2608=ZZ2608+ZZ2608 -+007610 775510 ZZ2608=ZZ2608+ZZ2608 -+007610 773220 ZZ2608=ZZ2608+ZZ2608 -+007610 766440 ZZ2608=ZZ2608+ZZ2608 -+007610 755100 ZZ2608=ZZ2608+ZZ2608 -+007610 732200 ZZ2608=ZZ2608+ZZ2608 -+007610 664400 ZZ2608=ZZ2608+ZZ2608 -+007610 000441 0 8192 -ZZ1608 -+007611 664400 0 ZZ2608 -- mark 7911, -219 /91 aqar -+007612 777110 ZZ2609=ZZ2609+ZZ2609 -+007612 776220 ZZ2609=ZZ2609+ZZ2609 -+007612 774440 ZZ2609=ZZ2609+ZZ2609 -+007612 771100 ZZ2609=ZZ2609+ZZ2609 -+007612 762200 ZZ2609=ZZ2609+ZZ2609 -+007612 744400 ZZ2609=ZZ2609+ZZ2609 -+007612 711000 ZZ2609=ZZ2609+ZZ2609 -+007612 622000 ZZ2609=ZZ2609+ZZ2609 -+007612 000431 0 8192 -ZZ1609 -+007613 622000 0 ZZ2609 -- mark 7919, 62 / 6 pisc -+007614 000174 ZZ2610=ZZ2610+ZZ2610 -+007614 000370 ZZ2610=ZZ2610+ZZ2610 -+007614 000760 ZZ2610=ZZ2610+ZZ2610 -+007614 001740 ZZ2610=ZZ2610+ZZ2610 -+007614 003700 ZZ2610=ZZ2610+ZZ2610 -+007614 007600 ZZ2610=ZZ2610+ZZ2610 -+007614 017400 ZZ2610=ZZ2610+ZZ2610 -+007614 037000 ZZ2610=ZZ2610+ZZ2610 -+007614 000421 0 8192 -ZZ1610 -+007615 037000 0 ZZ2610 -- mark 7923, -222 /93 aqar -+007616 777102 ZZ2611=ZZ2611+ZZ2611 -+007616 776204 ZZ2611=ZZ2611+ZZ2611 -+007616 774410 ZZ2611=ZZ2611+ZZ2611 -+007616 771020 ZZ2611=ZZ2611+ZZ2611 -+007616 762040 ZZ2611=ZZ2611+ZZ2611 -+007616 744100 ZZ2611=ZZ2611+ZZ2611 -+007616 710200 ZZ2611=ZZ2611+ZZ2611 -+007616 620400 ZZ2611=ZZ2611+ZZ2611 -+007616 000415 0 8192 -ZZ1611 -+007617 620400 0 ZZ2611 -- mark 7952, -470 /98 aqar -+007620 776122 ZZ2612=ZZ2612+ZZ2612 -+007620 774244 ZZ2612=ZZ2612+ZZ2612 -+007620 770510 ZZ2612=ZZ2612+ZZ2612 -+007620 761220 ZZ2612=ZZ2612+ZZ2612 -+007620 742440 ZZ2612=ZZ2612+ZZ2612 -+007620 705100 ZZ2612=ZZ2612+ZZ2612 -+007620 612200 ZZ2612=ZZ2612+ZZ2612 -+007620 424400 ZZ2612=ZZ2612+ZZ2612 -+007620 000360 0 8192 -ZZ1612 -+007621 424400 0 ZZ2612 -- mark 7969, -482 /99 aqar -+007622 776072 ZZ2613=ZZ2613+ZZ2613 -+007622 774164 ZZ2613=ZZ2613+ZZ2613 -+007622 770350 ZZ2613=ZZ2613+ZZ2613 -+007622 760720 ZZ2613=ZZ2613+ZZ2613 -+007622 741640 ZZ2613=ZZ2613+ZZ2613 -+007622 703500 ZZ2613=ZZ2613+ZZ2613 -+007622 607200 ZZ2613=ZZ2613+ZZ2613 -+007622 416400 ZZ2613=ZZ2613+ZZ2613 -+007622 000337 0 8192 -ZZ1613 -+007623 416400 0 ZZ2613 -- mark 7975, 16 / 8 pisc -+007624 000040 ZZ2614=ZZ2614+ZZ2614 -+007624 000100 ZZ2614=ZZ2614+ZZ2614 -+007624 000200 ZZ2614=ZZ2614+ZZ2614 -+007624 000400 ZZ2614=ZZ2614+ZZ2614 -+007624 001000 ZZ2614=ZZ2614+ZZ2614 -+007624 002000 ZZ2614=ZZ2614+ZZ2614 -+007624 004000 ZZ2614=ZZ2614+ZZ2614 -+007624 010000 ZZ2614=ZZ2614+ZZ2614 -+007624 000331 0 8192 -ZZ1614 -+007625 010000 0 ZZ2614 -- mark 7981, 133 /10 pisc -+007626 000412 ZZ2615=ZZ2615+ZZ2615 -+007626 001024 ZZ2615=ZZ2615+ZZ2615 -+007626 002050 ZZ2615=ZZ2615+ZZ2615 -+007626 004120 ZZ2615=ZZ2615+ZZ2615 -+007626 010240 ZZ2615=ZZ2615+ZZ2615 -+007626 020500 ZZ2615=ZZ2615+ZZ2615 -+007626 041200 ZZ2615=ZZ2615+ZZ2615 -+007626 102400 ZZ2615=ZZ2615+ZZ2615 -+007626 000323 0 8192 -ZZ1615 -+007627 102400 0 ZZ2615 -- mark 7988, 278 /70 pegs -+007630 001054 ZZ2616=ZZ2616+ZZ2616 -+007630 002130 ZZ2616=ZZ2616+ZZ2616 -+007630 004260 ZZ2616=ZZ2616+ZZ2616 -+007630 010540 ZZ2616=ZZ2616+ZZ2616 -+007630 021300 ZZ2616=ZZ2616+ZZ2616 -+007630 042600 ZZ2616=ZZ2616+ZZ2616 -+007630 105400 ZZ2616=ZZ2616+ZZ2616 -+007630 213000 ZZ2616=ZZ2616+ZZ2616 -+007630 000314 0 8192 -ZZ1616 -+007631 213000 0 ZZ2616 -- mark 8010, -489 /101 aqar -+007632 776054 ZZ2617=ZZ2617+ZZ2617 -+007632 774130 ZZ2617=ZZ2617+ZZ2617 -+007632 770260 ZZ2617=ZZ2617+ZZ2617 -+007632 760540 ZZ2617=ZZ2617+ZZ2617 -+007632 741300 ZZ2617=ZZ2617+ZZ2617 -+007632 702600 ZZ2617=ZZ2617+ZZ2617 -+007632 605400 ZZ2617=ZZ2617+ZZ2617 -+007632 413000 ZZ2617=ZZ2617+ZZ2617 -+007632 000266 0 8192 -ZZ1617 -+007633 413000 0 ZZ2617 -- mark 8049, 116 /17 pisc -+007634 000350 ZZ2618=ZZ2618+ZZ2618 -+007634 000720 ZZ2618=ZZ2618+ZZ2618 -+007634 001640 ZZ2618=ZZ2618+ZZ2618 -+007634 003500 ZZ2618=ZZ2618+ZZ2618 -+007634 007200 ZZ2618=ZZ2618+ZZ2618 -+007634 016400 ZZ2618=ZZ2618+ZZ2618 -+007634 035000 ZZ2618=ZZ2618+ZZ2618 -+007634 072000 ZZ2618=ZZ2618+ZZ2618 -+007634 000217 0 8192 -ZZ1618 -+007635 072000 0 ZZ2618 -- mark 8059, -418 /104 aqar -+007636 776272 ZZ2619=ZZ2619+ZZ2619 -+007636 774564 ZZ2619=ZZ2619+ZZ2619 -+007636 771350 ZZ2619=ZZ2619+ZZ2619 -+007636 762720 ZZ2619=ZZ2619+ZZ2619 -+007636 745640 ZZ2619=ZZ2619+ZZ2619 -+007636 713500 ZZ2619=ZZ2619+ZZ2619 -+007636 627200 ZZ2619=ZZ2619+ZZ2619 -+007636 456400 ZZ2619=ZZ2619+ZZ2619 -+007636 000205 0 8192 -ZZ1619 -+007637 456400 0 ZZ2619 -- mark 8061, 28 /18 pisc -+007640 000070 ZZ2620=ZZ2620+ZZ2620 -+007640 000160 ZZ2620=ZZ2620+ZZ2620 -+007640 000340 ZZ2620=ZZ2620+ZZ2620 -+007640 000700 ZZ2620=ZZ2620+ZZ2620 -+007640 001600 ZZ2620=ZZ2620+ZZ2620 -+007640 003400 ZZ2620=ZZ2620+ZZ2620 -+007640 007000 ZZ2620=ZZ2620+ZZ2620 -+007640 016000 ZZ2620=ZZ2620+ZZ2620 -+007640 000203 0 8192 -ZZ1620 -+007641 016000 0 ZZ2620 -- mark 8064, -344 /105 aqar -+007642 776516 ZZ2621=ZZ2621+ZZ2621 -+007642 775234 ZZ2621=ZZ2621+ZZ2621 -+007642 772470 ZZ2621=ZZ2621+ZZ2621 -+007642 765160 ZZ2621=ZZ2621+ZZ2621 -+007642 752340 ZZ2621=ZZ2621+ZZ2621 -+007642 724700 ZZ2621=ZZ2621+ZZ2621 -+007642 651600 ZZ2621=ZZ2621+ZZ2621 -+007642 523400 ZZ2621=ZZ2621+ZZ2621 -+007642 000200 0 8192 -ZZ1621 -+007643 523400 0 ZZ2621 -- mark 8159, 144 /28 pisc -+007644 000440 ZZ2622=ZZ2622+ZZ2622 -+007644 001100 ZZ2622=ZZ2622+ZZ2622 -+007644 002200 ZZ2622=ZZ2622+ZZ2622 -+007644 004400 ZZ2622=ZZ2622+ZZ2622 -+007644 011000 ZZ2622=ZZ2622+ZZ2622 -+007644 022000 ZZ2622=ZZ2622+ZZ2622 -+007644 044000 ZZ2622=ZZ2622+ZZ2622 -+007644 110000 ZZ2622=ZZ2622+ZZ2622 -+007644 000041 0 8192 -ZZ1622 -+007645 110000 0 ZZ2622 -- mark 8174, -149 /30 pisc -+007646 777324 ZZ2623=ZZ2623+ZZ2623 -+007646 776650 ZZ2623=ZZ2623+ZZ2623 -+007646 775520 ZZ2623=ZZ2623+ZZ2623 -+007646 773240 ZZ2623=ZZ2623+ZZ2623 -+007646 766500 ZZ2623=ZZ2623+ZZ2623 -+007646 755200 ZZ2623=ZZ2623+ZZ2623 -+007646 732400 ZZ2623=ZZ2623+ZZ2623 -+007646 665000 ZZ2623=ZZ2623+ZZ2623 -+007646 000022 0 8192 -ZZ1623 -+007647 665000 0 ZZ2623 - 007650 4q, -- mark 8188, -407 / 2 ceti -+007650 776320 ZZ2624=ZZ2624+ZZ2624 -+007650 774640 ZZ2624=ZZ2624+ZZ2624 -+007650 771500 ZZ2624=ZZ2624+ZZ2624 -+007650 763200 ZZ2624=ZZ2624+ZZ2624 -+007650 746400 ZZ2624=ZZ2624+ZZ2624 -+007650 715000 ZZ2624=ZZ2624+ZZ2624 -+007650 632000 ZZ2624=ZZ2624+ZZ2624 -+007650 464000 ZZ2624=ZZ2624+ZZ2624 -+007650 000004 0 8192 -ZZ1624 -+007651 464000 0 ZZ2624 - 007652 start 4 -` diff --git a/src/pkg/exp/spacewar/pdp1.go b/src/pkg/exp/spacewar/pdp1.go deleted file mode 100644 index e3abd6807..000000000 --- a/src/pkg/exp/spacewar/pdp1.go +++ /dev/null @@ -1,389 +0,0 @@ -// Copyright (c) 1996 Barry Silverman, Brian Silverman, Vadim Gerasimov. -// Portions Copyright (c) 2009 The Go Authors. -// -// 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. - -// This package and spacewar.go implement a simple PDP-1 emulator -// complete enough to run the original PDP-1 video game Spacewar! -// See ../../nacl/README for details on running them. -// -// They are a translation of the Java emulator pdp1.java in -// http://spacewar.oversigma.com/sources/sources.zip. -// -// See also the PDP-1 handbook at http://www.dbit.com/~greeng3/pdp1/pdp1.html -// -// http://spacewar.oversigma.com/readme.html reads: -// -// Spacewar! was conceived in 1961 by Martin Graetz, Stephen Russell, -// and Wayne Wiitanen. It was first realized on the PDP-1 in 1962 by -// Stephen Russell, Peter Samson, Dan Edwards, and Martin Graetz, -// together with Alan Kotok, Steve Piner, and Robert A Saunders. -// Spacewar! is in the public domain, but this credit paragraph must -// accompany all distributed versions of the program. -// -// This is the original version! Martin Graetz provided us with a -// printed version of the source. We typed in in again - it was about -// 40 pages long - and re-assembled it with a PDP-1 assembler written -// in PERL. The resulting binary runs on a PDP-1 emulator written as -// a Java applet. The code is extremely faithful to the original. There -// are only two changes. 1)The spaceships have been made bigger and -// 2) The overall timing has been special cased to deal with varying -// machine speeds. -// -// The "a", "s", "d", "f" keys control one of the spaceships. The "k", -// "l", ";", "'" keys control the other. The controls are spin one -// way, spin the other, thrust, and fire. -// -// Barry Silverman -// Brian Silverman -// Vadim Gerasimov -// -package pdp1 - -import ( - "bufio" - "fmt" - "os" - "io" -) - -type Word uint32 - -const mask = 0777777 -const sign = 0400000 - -const ( - _ = iota // 00 - opAND - opIOR - opXOR - opXCT - _ - _ - opCALJDA - - opLAC // 10 - opLIO - opDAC - opDAP - _ - opDIO - opDZM - _ - - opADD // 20 - opSUB - opIDX - opISP - opSAD - opSAS - opMUS - opDIS - - opJMP // 30 - opJSP - opSKP - opSFT - opLAW - opIOT - _ - opOPR -) - -// A Trapper represents an object with a Trap method. -// The machine calls the Trap method to implement the -// PDP-1 IOT instruction. -type Trapper interface { - Trap(y Word) -} - -// An M represents the machine state of a PDP-1. -// Clients can set Display to install an output device. -type M struct { - AC, IO, PC, OV Word - Mem [010000]Word - Flag [7]bool - Sense [7]bool - Halt bool -} - - -// Step runs a single machine instruction. -func (m *M) Step(t Trapper) os.Error { - inst := m.Mem[m.PC] - m.PC++ - return m.run(inst, t) -} - -// Normalize actual 32-bit integer i to 18-bit ones-complement integer. -// Interpret mod 0777777, because 0777777 == -0 == +0 == 0000000. -func norm(i Word) Word { - i += i >> 18 - i &= mask - if i == mask { - i = 0 - } - return i -} - -type UnknownInstrError struct { - Inst Word - PC Word -} - -func (e UnknownInstrError) String() string { - return fmt.Sprintf("unknown instruction %06o at %06o", e.Inst, e.PC) -} - -type HaltError Word - -func (e HaltError) String() string { - return fmt.Sprintf("executed HLT instruction at %06o", e) -} - -type LoopError Word - -func (e LoopError) String() string { return fmt.Sprintf("indirect load looping at %06o", e) } - -func (m *M) run(inst Word, t Trapper) os.Error { - ib, y := (inst>>12)&1, inst&07777 - op := inst >> 13 - if op < opSKP && op != opCALJDA { - for n := 0; ib != 0; n++ { - if n > 07777 { - return LoopError(m.PC - 1) - } - ib = (m.Mem[y] >> 12) & 1 - y = m.Mem[y] & 07777 - } - } - - switch op { - case opAND: - m.AC &= m.Mem[y] - case opIOR: - m.AC |= m.Mem[y] - case opXOR: - m.AC ^= m.Mem[y] - case opXCT: - m.run(m.Mem[y], t) - case opCALJDA: - a := y - if ib == 0 { - a = 64 - } - m.Mem[a] = m.AC - m.AC = (m.OV << 17) + m.PC - m.PC = a + 1 - case opLAC: - m.AC = m.Mem[y] - case opLIO: - m.IO = m.Mem[y] - case opDAC: - m.Mem[y] = m.AC - case opDAP: - m.Mem[y] = m.Mem[y]&0770000 | m.AC&07777 - case opDIO: - m.Mem[y] = m.IO - case opDZM: - m.Mem[y] = 0 - case opADD: - m.AC += m.Mem[y] - m.OV = m.AC >> 18 - m.AC = norm(m.AC) - case opSUB: - diffSigns := (m.AC^m.Mem[y])>>17 == 1 - m.AC += m.Mem[y] ^ mask - m.AC = norm(m.AC) - if diffSigns && m.Mem[y]>>17 == m.AC>>17 { - m.OV = 1 - } - case opIDX: - m.AC = norm(m.Mem[y] + 1) - m.Mem[y] = m.AC - case opISP: - m.AC = norm(m.Mem[y] + 1) - m.Mem[y] = m.AC - if m.AC&sign == 0 { - m.PC++ - } - case opSAD: - if m.AC != m.Mem[y] { - m.PC++ - } - case opSAS: - if m.AC == m.Mem[y] { - m.PC++ - } - case opMUS: - if m.IO&1 == 1 { - m.AC += m.Mem[y] - m.AC = norm(m.AC) - } - m.IO = (m.IO>>1 | m.AC<<17) & mask - m.AC >>= 1 - case opDIS: - m.AC, m.IO = (m.AC<<1|m.IO>>17)&mask, - ((m.IO<<1|m.AC>>17)&mask)^1 - if m.IO&1 == 1 { - m.AC = m.AC + (m.Mem[y] ^ mask) - } else { - m.AC = m.AC + 1 + m.Mem[y] - } - m.AC = norm(m.AC) - case opJMP: - m.PC = y - case opJSP: - m.AC = (m.OV << 17) + m.PC - m.PC = y - case opSKP: - cond := y&0100 == 0100 && m.AC == 0 || - y&0200 == 0200 && m.AC>>17 == 0 || - y&0400 == 0400 && m.AC>>17 == 1 || - y&01000 == 01000 && m.OV == 0 || - y&02000 == 02000 && m.IO>>17 == 0 || - y&7 != 0 && !m.Flag[y&7] || - y&070 != 0 && !m.Sense[(y&070)>>3] || - y&070 == 010 - if (ib == 0) == cond { - m.PC++ - } - if y&01000 == 01000 { - m.OV = 0 - } - case opSFT: - for count := inst & 0777; count != 0; count >>= 1 { - if count&1 == 0 { - continue - } - switch (inst >> 9) & 017 { - case 001: // rotate AC left - m.AC = (m.AC<<1 | m.AC>>17) & mask - case 002: // rotate IO left - m.IO = (m.IO<<1 | m.IO>>17) & mask - case 003: // rotate AC and IO left. - w := uint64(m.AC)<<18 | uint64(m.IO) - w = w<<1 | w>>35 - m.AC = Word(w>>18) & mask - m.IO = Word(w) & mask - case 005: // shift AC left (excluding sign bit) - m.AC = (m.AC<<1|m.AC>>17)&mask&^sign | m.AC&sign - case 006: // shift IO left (excluding sign bit) - m.IO = (m.IO<<1|m.IO>>17)&mask&^sign | m.IO&sign - case 007: // shift AC and IO left (excluding AC's sign bit) - w := uint64(m.AC)<<18 | uint64(m.IO) - w = w<<1 | w>>35 - m.AC = Word(w>>18)&mask&^sign | m.AC&sign - m.IO = Word(w)&mask&^sign | m.AC&sign - case 011: // rotate AC right - m.AC = (m.AC>>1 | m.AC<<17) & mask - case 012: // rotate IO right - m.IO = (m.IO>>1 | m.IO<<17) & mask - case 013: // rotate AC and IO right - w := uint64(m.AC)<<18 | uint64(m.IO) - w = w>>1 | w<<35 - m.AC = Word(w>>18) & mask - m.IO = Word(w) & mask - case 015: // shift AC right (excluding sign bit) - m.AC = m.AC>>1 | m.AC&sign - case 016: // shift IO right (excluding sign bit) - m.IO = m.IO>>1 | m.IO&sign - case 017: // shift AC and IO right (excluding AC's sign bit) - w := uint64(m.AC)<<18 | uint64(m.IO) - w = w >> 1 - m.AC = Word(w>>18) | m.AC&sign - m.IO = Word(w) & mask - default: - goto Unknown - } - } - case opLAW: - if ib == 0 { - m.AC = y - } else { - m.AC = y ^ mask - } - case opIOT: - t.Trap(y) - case opOPR: - if y&0200 == 0200 { - m.AC = 0 - } - if y&04000 == 04000 { - m.IO = 0 - } - if y&01000 == 01000 { - m.AC ^= mask - } - if y&0400 == 0400 { - m.PC-- - return HaltError(m.PC) - } - switch i, f := y&7, y&010 == 010; { - case i == 7: - for i := 2; i < 7; i++ { - m.Flag[i] = f - } - case i >= 2: - m.Flag[i] = f - } - default: - Unknown: - return UnknownInstrError{inst, m.PC - 1} - } - return nil -} - -// Load loads the machine's memory from a text input file -// listing octal address-value pairs, one per line, matching the -// regular expression ^[ +]([0-7]+)\t([0-7]+). -func (m *M) Load(r io.Reader) os.Error { - b := bufio.NewReader(r) - for { - line, err := b.ReadString('\n') - if err != nil { - if err != os.EOF { - return err - } - break - } - // look for ^[ +]([0-9]+)\t([0-9]+) - if line[0] != ' ' && line[0] != '+' { - continue - } - i := 1 - a := Word(0) - for ; i < len(line) && '0' <= line[i] && line[i] <= '7'; i++ { - a = a*8 + Word(line[i]-'0') - } - if i >= len(line) || line[i] != '\t' || i == 1 { - continue - } - v := Word(0) - j := i - for i++; i < len(line) && '0' <= line[i] && line[i] <= '7'; i++ { - v = v*8 + Word(line[i]-'0') - } - if i == j { - continue - } - m.Mem[a] = v - } - return nil -} diff --git a/src/pkg/exp/spacewar/spacewar.go b/src/pkg/exp/spacewar/spacewar.go deleted file mode 100644 index 7333220ef..000000000 --- a/src/pkg/exp/spacewar/spacewar.go +++ /dev/null @@ -1,196 +0,0 @@ -// Copyright (c) 1996 Barry Silverman, Brian Silverman, Vadim Gerasimov. -// Portions Copyright (c) 2009 The Go Authors. -// -// 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. - -// See ../../nacl/README. - -package main - -import ( - "bytes" - "exp/draw" - "exp/nacl/av" - "exp/nacl/srpc" - "image" - "log" - "os" - "runtime" - "time" - "./pdp1" -) - -func main() { - runtime.LockOSThread() - if srpc.Enabled() { - go srpc.ServeRuntime() - } - - w, err := av.Init(av.SubsystemVideo, 512, 512) - if err != nil { - log.Exitf("av.Init: %s", err) - } - - go quitter(w.QuitChan()) - - var m SpacewarPDP1 - m.Init(w) - m.PC = 4 - f := bytes.NewBuffer([]byte(spacewarCode)) - if err = m.Load(f); err != nil { - log.Exitf("loading %s: %s", "spacewar.lst", err) - } - for err == nil { - //fmt.Printf("step PC=%06o ", m.PC); - //fmt.Printf("inst=%06o AC=%06o IO=%06o OV=%o\n", - // m.Mem[m.PC], m.AC, m.IO, m.OV); - err = m.Step() - } - log.Exitf("step: %s", err) -} - -func quitter(c <-chan bool) { - <-c - os.Exit(0) -} - -// A SpacewarPDP1 is a PDP-1 machine configured to run Spacewar! -// It responds to traps by drawing on the display, and it flushes the -// display and pauses every second time the program counter reaches -// instruction 02051. -type SpacewarPDP1 struct { - pdp1.M - nframe int - frameTime int64 - ctxt draw.Context - dx, dy int - screen draw.Image - ctl pdp1.Word - kc <-chan int - colorModel image.ColorModel - cmap []image.Color - pix [][]uint8 -} - -func min(a, b int) int { - if a < b { - return a - } - return b -} - -func (m *SpacewarPDP1) Init(ctxt draw.Context) { - m.ctxt = ctxt - m.kc = ctxt.KeyboardChan() - m.screen = ctxt.Screen() - m.dx = m.screen.Width() - m.dy = m.screen.Height() - m.colorModel = m.screen.ColorModel() - m.pix = make([][]uint8, m.dy) - for i := range m.pix { - m.pix[i] = make([]uint8, m.dx) - } - m.cmap = make([]image.Color, 256) - for i := range m.cmap { - var r, g, b uint8 - r = uint8(min(0, 255)) - g = uint8(min(i*2, 255)) - b = uint8(min(0, 255)) - m.cmap[i] = m.colorModel.Convert(image.RGBAColor{r, g, b, 0xff}) - } -} - -const ( - frameDelay = 56 * 1e6 // 56 ms -) - -var ctlBits = [...]pdp1.Word{ - 'f': 0000001, - 'd': 0000002, - 'a': 0000004, - 's': 0000010, - '\'': 0040000, - ';': 0100000, - 'k': 0200000, - 'l': 0400000, -} - -func (m *SpacewarPDP1) Step() os.Error { - if m.PC == 02051 { - m.pollInput() - m.nframe++ - if m.nframe&1 == 0 { - m.flush() - t := time.Nanoseconds() - if t >= m.frameTime+3*frameDelay { - m.frameTime = t - } else { - m.frameTime += frameDelay - for t < m.frameTime { - time.Sleep(m.frameTime - t) - t = time.Nanoseconds() - } - } - } - } - return m.M.Step(m) -} - -func (m *SpacewarPDP1) Trap(y pdp1.Word) { - switch y & 077 { - case 7: - x := int(m.AC+0400000) & 0777777 - y := int(m.IO+0400000) & 0777777 - x = x * m.dx / 0777777 - y = y * m.dy / 0777777 - if 0 <= x && x < m.dx && 0 <= y && y < m.dy { - n := uint8(min(int(m.pix[y][x])+128, 255)) - m.pix[y][x] = n - } - case 011: - m.IO = m.ctl - } -} - -func (m *SpacewarPDP1) flush() { - // Update screen image; simulate phosphor decay. - for y := 0; y < m.dy; y++ { - for x := 0; x < m.dx; x++ { - m.screen.Set(x, y, m.cmap[m.pix[y][x]]) - m.pix[y][x] >>= 1 - } - } - m.ctxt.FlushImage() -} - -func (m *SpacewarPDP1) pollInput() { - for { - select { - case ch := <-m.kc: - if 0 <= ch && ch < len(ctlBits) { - m.ctl |= ctlBits[ch] - } - if 0 <= -ch && -ch < len(ctlBits) { - m.ctl &^= ctlBits[-ch] - } - default: - return - } - } -} diff --git a/src/pkg/exp/spacewar/spacewar.html b/src/pkg/exp/spacewar/spacewar.html deleted file mode 100644 index 8f49b1c34..000000000 --- a/src/pkg/exp/spacewar/spacewar.html +++ /dev/null @@ -1,21 +0,0 @@ - -<h1>Spacewar</h1> -<table> -<tr><td valign=top> -<embed name="nacl_module" id="pluginobj" src="8.out" type="application/x-nacl-srpc" width=512 height=512> -<td valign=top> -This is a Go translation of the Java emulator pdp1.java in -<a href="http://spacewar.oversigma.com/sources/sources.zip">http://spacewar.oversigma.com/sources/sources.zip</a>. -See <a href="pdp1.go">pdp1.go</a>, <a href="spacewar.go">spacewar.go</a>, -and -<a href="http://spacewar.oversigma.com/readme.html">http://spacewar.oversigma.com/readme.html</a>. -<br><br> -The <i>a</i>, <i>s</i>, <i>d</i>, <i>f</i> keys control one of the spaceships. The <i>k</i>, -<i>l</i>, <i>;</i>, <i>'</i> keys control the other. The controls are spin one -way, spin the other, thrust, and fire. -<br> -<br> -<b>You may need to click on the game window to -focus the keyboard on it.</b> - -</table> |