Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
M
mjtest-tests
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Service Desk
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Operations
Operations
Incidents
Environments
Packages & Registries
Packages & Registries
Package Registry
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
uydwl
mjtest-tests
Commits
67310848
Commit
67310848
authored
Jan 14, 2019
by
andreas.fried
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
Add Speedcenter testcases.
parent
19948c3b
Changes
8
Hide whitespace changes
Inline
Side-by-side
Showing
8 changed files
with
1918 additions
and
0 deletions
+1918
-0
exec/bench_BigTensorProduct.inputc
exec/bench_BigTensorProduct.inputc
+1
-0
exec/bench_BigTensorProduct.java
exec/bench_BigTensorProduct.java
+379
-0
exec/bench_binarytrees.java
exec/bench_binarytrees.java
+180
-0
exec/bench_conways_game_of_life.inputc
exec/bench_conways_game_of_life.inputc
+1
-0
exec/bench_conways_game_of_life.java
exec/bench_conways_game_of_life.java
+357
-0
exec/bench_fannkuchredux.java
exec/bench_fannkuchredux.java
+168
-0
exec/bench_math.inputc
exec/bench_math.inputc
+1
-0
exec/bench_math.java
exec/bench_math.java
+831
-0
No files found.
exec/bench_BigTensorProduct.inputc
0 → 100644
View file @
67310848
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
\ No newline at end of file
exec/bench_BigTensorProduct.java
0 → 100644
View file @
67310848
/**
* Linear congruence generator for pseudo random numbers.
*/
class
LCG
{
public
int
a
;
public
int
c
;
public
int
m
;
public
int
val
;
public
LCG
initWithDefault
(
int
seed
){
return
init
(
2147483629
,
2147483587
,
2147483647
,
seed
);
}
public
LCG
initWithDefault2
(
int
seed
){
return
init
(
2147480707
,
2147480707
,
2147482367
,
seed
);
}
public
LCG
init
(
int
a_
,
int
c_
,
int
m_
,
int
startVal
)
{
a
=
a_
;
c
=
c_
;
m
=
m_
;
val
=
startVal
;
return
this
;
}
public
int
nextVal
()
{
return
val
=
(
a
*
val
+
c
)
%
m
;
}
/* util functions */
public
int
abs
(
int
v
)
{
if
(
v
>=
0
)
return
v
;
return
-
v
;
}
public
void
runTest
()
{
int
i
=
0
;
while
(
i
<
100
)
{
i
=
i
+
1
;
System
.
out
.
println
(
abs
(
nextVal
()));
}
/*System.out.println(-2147483648 / -1);*/
}
/**
* @param min minimum number
* @param max exclusive range end
*/
public
int
nextRange
(
int
min
,
int
max
){
return
nextVal
()
%
(
max
-
min
)
+
min
;
}
}
/* Adapted from: https://en.wikipedia.org/wiki/Lehmer_random_number_generator */
class
LehmerRandom
{
public
int
M
;
/* 2^31 - 1 (A large prime number) */
public
int
A
;
/* Prime root of M, passes statistical tests and produces a full cycle */
public
int
Q
;
/* M / A (To avoid overflow on A * seed) */
public
int
R
;
/* M % A (To avoid overflow on A * seed) */
public
int
seed
;
public
LehmerRandom
init
(
int
seed
){
this
.
M
=
2147483647
;
this
.
A
=
16807
;
this
.
Q
=
127773
;
this
.
R
=
2836
;
this
.
seed
=
seed
;
return
this
;
}
public
LehmerRandom
initWithDefault
(){
return
init
(
2147480677
);
}
public
int
random
()
{
int
hi
=
seed
/
Q
;
int
lo
=
seed
%
Q
;
int
test
=
A
*
lo
-
R
*
hi
;
if
(
test
<=
0
)
test
=
test
+
M
;
seed
=
test
;
return
test
;
}
public
int
next
(){
return
random
();
}
/**
* @param min minimum number
* @param max exclusive range end
*/
public
int
nextRange
(
int
min
,
int
max
){
return
next
()
%
(
max
-
min
)
+
min
;
}
public
int
[]
intArray
(
int
size
,
int
min
,
int
maxEx
){
int
[]
arr
=
new
int
[
size
];
int
i
=
0
;
while
(
i
<
size
){
arr
[
i
]
=
nextRange
(
min
,
maxEx
);
i
=
i
+
1
;
}
return
arr
;
}
public
boolean
nextBoolean
(){
return
next
()
%
2
==
0
;
}
public
boolean
[]
booleanArray
(
int
size
){
boolean
[]
arr
=
new
boolean
[
size
];
int
i
=
0
;
while
(
i
<
size
){
arr
[
i
]
=
nextBoolean
();
i
=
i
+
1
;
}
return
arr
;
}
public
void
shuffleIntArray
(
int
[]
arr
,
int
size
)
{
int
i
=
size
-
1
;
while
(
i
>
0
){
int
index
=
nextRange
(
0
,
i
+
1
);
int
a
=
arr
[
index
];
arr
[
index
]
=
arr
[
i
];
arr
[
i
]
=
a
;
i
=
i
-
1
;
}
}
}
/**
* Calculate the tensor product for a dimension of 7
*/
class
BigTensorProduct
{
public
static
void
main
(
String
[]
args
)
throws
Exception
{
BigTensorProduct
prod
=
new
BigTensorProduct
();
prod
.
run
(
15
,
false
,
System
.
in
.
read
());
}
public
void
run
(
int
n
,
boolean
outputMatrix
,
int
seed
){
LCG
random
=
new
LCG
().
initWithDefault2
(
seed
);
int
sum
=
0
;
int
[]
indezes
=
new
int
[
7
];
int
j
=
0
;
while
(
j
<
7
){
indezes
[
j
]
=
0
;
j
=
j
+
1
;
}
int
[][][][][][][]
arr
=
randomIntArray
(
n
,
seed
+
1
);
int
[][]
vectors
=
randomMatrix
(
7
,
n
,
seed
+
2
);
while
(
indezes
[
0
]
<
n
)
{
while
(
indezes
[
1
]
<
n
)
{
while
(
indezes
[
2
]
<
n
)
{
while
(
indezes
[
3
]
<
n
)
{
while
(
indezes
[
4
]
<
n
)
{
while
(
indezes
[
5
]
<
n
)
{
while
(
indezes
[
6
]
<
n
)
{
int
val
=
1
;
int
i
=
0
;
while
(
i
<
7
){
val
=
val
*
vectors
[
i
][
indezes
[
i
]];
i
=
i
+
1
;
}
if
(
outputMatrix
){
System
.
out
.
println
(
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]]);
}
sum
=
sum
+
val
*
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]];
indezes
[
6
]
=
indezes
[
6
]
+
1
;
}
indezes
[
6
]
=
0
;
indezes
[
5
]
=
indezes
[
5
]
+
1
;
}
indezes
[
5
]
=
0
;
indezes
[
4
]
=
indezes
[
4
]
+
1
;
}
indezes
[
4
]
=
0
;
indezes
[
3
]
=
indezes
[
3
]
+
1
;
}
indezes
[
3
]
=
0
;
indezes
[
2
]
=
indezes
[
2
]
+
1
;
}
indezes
[
2
]
=
0
;
indezes
[
1
]
=
indezes
[
1
]
+
1
;
}
indezes
[
1
]
=
0
;
indezes
[
0
]
=
indezes
[
0
]
+
1
;
}
System
.
out
.
println
(
sum
);
}
public
void
runWithNumbers
(
int
n
,
boolean
outputMatrix
,
int
seed
){
LCG
random
=
new
LCG
().
initWithDefault2
(
seed
);
Number
sum
=
new
Number
().
init
(
0
);
int
[]
indezes
=
new
int
[
7
];
int
j
=
0
;
while
(
j
<
7
){
indezes
[
j
]
=
0
;
j
=
j
+
1
;
}
Number
[][][][][][][]
arr
=
randomNumberArray
(
n
,
seed
+
1
);
Number
[][]
vectors
=
randomNumberMatrix
(
7
,
n
,
seed
+
2
);
while
(
indezes
[
0
]
<
n
)
{
while
(
indezes
[
1
]
<
n
)
{
while
(
indezes
[
2
]
<
n
)
{
while
(
indezes
[
3
]
<
n
)
{
while
(
indezes
[
4
]
<
n
)
{
while
(
indezes
[
5
]
<
n
)
{
while
(
indezes
[
6
]
<
n
)
{
Number
val
=
new
Number
().
init
(
1
);
int
i
=
0
;
while
(
i
<
7
){
val
=
val
.
mul
(
vectors
[
i
][
indezes
[
i
]]);
i
=
i
+
1
;
}
if
(
outputMatrix
){
System
.
out
.
println
(
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]].
val
);
}
sum
=
sum
.
add
(
val
.
mul
(
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]]));
indezes
[
6
]
=
indezes
[
6
]
+
1
;
}
indezes
[
6
]
=
0
;
indezes
[
5
]
=
indezes
[
5
]
+
1
;
}
indezes
[
5
]
=
0
;
indezes
[
4
]
=
indezes
[
4
]
+
1
;
}
indezes
[
4
]
=
0
;
indezes
[
3
]
=
indezes
[
3
]
+
1
;
}
indezes
[
3
]
=
0
;
indezes
[
2
]
=
indezes
[
2
]
+
1
;
}
System
.
out
.
println
(
sum
.
val
);
indezes
[
2
]
=
0
;
indezes
[
1
]
=
indezes
[
1
]
+
1
;
}
indezes
[
1
]
=
0
;
indezes
[
0
]
=
indezes
[
0
]
+
1
;
}
System
.
out
.
println
(
sum
.
val
);
}
public
int
[][]
randomMatrix
(
int
number
,
int
n
,
int
seed
){
LehmerRandom
random
=
new
LehmerRandom
().
init
(
seed
);
int
[][]
ret
=
new
int
[
number
][];
int
i
=
0
;
while
(
i
<
number
){
ret
[
i
]
=
new
int
[
n
];
int
j
=
0
;
while
(
j
<
n
){
ret
[
i
][
j
]
=
random
.
next
();
j
=
j
+
1
;
}
i
=
i
+
1
;
}
return
ret
;
}
public
Number
[][]
randomNumberMatrix
(
int
number
,
int
n
,
int
seed
){
LehmerRandom
random
=
new
LehmerRandom
().
init
(
seed
);
Number
[][]
ret
=
new
Number
[
number
][];
int
i
=
0
;
while
(
i
<
number
){
ret
[
i
]
=
new
Number
[
n
];
int
j
=
0
;
while
(
j
<
n
){
ret
[
i
][
j
]
=
new
Number
().
init
(
random
.
next
());
j
=
j
+
1
;
}
i
=
i
+
1
;
}
return
ret
;
}
public
int
[][][][][][][]
randomIntArray
(
int
n
,
int
seed
){
LCG
lcg
=
new
LCG
().
initWithDefault
(
seed
);
int
[][][][][][][]
arr
=
new
int
[
n
][][][][][][];
int
[]
indezes
=
new
int
[
7
];
while
(
indezes
[
0
]
<
n
)
{
arr
[
indezes
[
0
]]
=
new
int
[
n
][][][][][];
while
(
indezes
[
1
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]]
=
new
int
[
n
][][][][];
while
(
indezes
[
2
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]]
=
new
int
[
n
][][][];
while
(
indezes
[
3
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]]
=
new
int
[
n
][][];
while
(
indezes
[
4
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]]
=
new
int
[
n
][];
while
(
indezes
[
5
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]]
=
new
int
[
n
];
while
(
indezes
[
6
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]]
=
lcg
.
nextVal
();
indezes
[
6
]
=
indezes
[
6
]
+
1
;
}
indezes
[
6
]
=
0
;
indezes
[
5
]
=
indezes
[
5
]
+
1
;
}
indezes
[
5
]
=
0
;
indezes
[
4
]
=
indezes
[
4
]
+
1
;
}
indezes
[
4
]
=
0
;
indezes
[
3
]
=
indezes
[
3
]
+
1
;
}
indezes
[
3
]
=
0
;
indezes
[
2
]
=
indezes
[
2
]
+
1
;
}
indezes
[
2
]
=
0
;
indezes
[
1
]
=
indezes
[
1
]
+
1
;
}
indezes
[
1
]
=
0
;
indezes
[
0
]
=
indezes
[
0
]
+
1
;
}
return
arr
;
}
public
Number
[][][][][][][]
randomNumberArray
(
int
n
,
int
seed
){
LCG
lcg
=
new
LCG
().
initWithDefault
(
seed
);
Number
[][][][][][][]
arr
=
new
Number
[
n
][][][][][][];
int
[]
indezes
=
new
int
[
7
];
while
(
indezes
[
0
]
<
n
)
{
arr
[
indezes
[
0
]]
=
new
Number
[
n
][][][][][];
while
(
indezes
[
1
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]]
=
new
Number
[
n
][][][][];
while
(
indezes
[
2
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]]
=
new
Number
[
n
][][][];
while
(
indezes
[
3
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]]
=
new
Number
[
n
][][];
while
(
indezes
[
4
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]]
=
new
Number
[
n
][];
while
(
indezes
[
5
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]]
=
new
Number
[
n
];
while
(
indezes
[
6
]
<
n
)
{
arr
[
indezes
[
0
]][
indezes
[
1
]][
indezes
[
2
]][
indezes
[
3
]][
indezes
[
4
]][
indezes
[
5
]][
indezes
[
6
]]
=
new
Number
().
init
(
lcg
.
nextRange
(-
1000
,
1000
));
indezes
[
6
]
=
indezes
[
6
]
+
1
;
}
indezes
[
6
]
=
0
;
indezes
[
5
]
=
indezes
[
5
]
+
1
;
}
indezes
[
5
]
=
0
;
indezes
[
4
]
=
indezes
[
4
]
+
1
;
}
indezes
[
4
]
=
0
;
indezes
[
3
]
=
indezes
[
3
]
+
1
;
}
indezes
[
3
]
=
0
;
indezes
[
2
]
=
indezes
[
2
]
+
1
;
}
indezes
[
2
]
=
0
;
indezes
[
1
]
=
indezes
[
1
]
+
1
;
}
indezes
[
1
]
=
0
;
indezes
[
0
]
=
indezes
[
0
]
+
1
;
}
return
arr
;
}
}
class
Number
{
public
int
val
;
public
Number
init
(
int
val
){
this
.
val
=
val
;
return
this
;
}
public
Number
mul
(
Number
other
){
return
new
Number
().
init
(
other
.
val
*
val
);
}
public
Number
add
(
Number
other
){
return
new
Number
().
init
(
other
.
val
+
val
);
}
}
exec/bench_binarytrees.java
0 → 100644
View file @
67310848
class
Math
{
public
int
pow
(
int
v
,
int
exp
){
if
(
exp
<
0
){
return
1
/
pow
(
v
,
-
exp
);
}
else
if
(
exp
==
0
){
return
1
;
}
else
{
int
ret
=
1
;
while
(
exp
>
0
){
if
(
exp
%
2
==
0
){
v
=
v
*
v
;
exp
=
exp
/
2
;
}
else
{
ret
=
ret
*
v
;
exp
=
exp
-
1
;
}
}
return
ret
;
}
}
public
int
factorial
(
int
val
){
int
ret
=
1
;
int
sign
=
signum
(
val
);
if
(
val
<
0
){
val
=
-
val
;
}
if
(
val
==
0
){
return
1
;
}
while
(
val
>
0
){
ret
=
ret
*
val
;
val
=
val
-
1
;
}
return
ret
*
sign
;
}
public
int
min
(
int
s
,
int
t
){
if
(
s
<
t
){
return
s
;
}
return
t
;
}
public
int
max
(
int
s
,
int
t
){
if
(
s
>
t
){
return
s
;
}
return
t
;
}
public
int
lengthInChars
(
int
num
){
int
len
=
1
;
if
(
num
<
0
){
len
=
len
+
1
;
num
=
-
num
;
}
while
(
num
>
10
){
num
=
num
/
10
;
len
=
len
+
1
;
}
return
len
;
}
public
int
signum
(
int
num
){
if
(
num
==
0
){
return
0
;
}
if
(
num
<
0
){
return
-
1
;
}
return
1
;
}
public
int
abs
(
int
num
){
if
(
num
<
0
){
return
-
num
;
}
return
num
;
}
}
/*
Adapted from the following source:
The Computer Language Benchmarks Game
http://benchmarksgame.alioth.debian.org/
contributed by Jarkko Miettinen
*/
class
binarytrees
{
public
int
minDepth
;
public
static
void
main
(
String
[]
args
){
new
binarytrees
().
init
().
run
(
19
);
}
public
binarytrees
init
(){
minDepth
=
4
;
return
this
;
}
public
void
run
(
int
n
){
int
maxDepth
=
0
;
if
(
minDepth
+
2
>
n
){
maxDepth
=
minDepth
+
2
;
}
else
{
maxDepth
=
n
;
}
int
stretchDepth
=
maxDepth
+
1
;
int
check
=
bottomUpTree
(
0
,
stretchDepth
).
itemCheck
();
/*System.out.println("stretch tree of depth "+stretchDepth+"\t check: " + check);*/
System
.
out
.
println
(
stretchDepth
);
System
.
out
.
println
(
check
);
TreeNode
longLivedTree
=
bottomUpTree
(
0
,
maxDepth
);
int
depth
=
minDepth
;
while
(
depth
<=
maxDepth
){
int
iterations
=
new
Math
().
pow
(
2
,
maxDepth
-
depth
+
minDepth
);
check
=
0
;
int
i
=
1
;
while
(
i
<=
iterations
){
check
=
check
+
(
bottomUpTree
(
i
,
depth
)).
itemCheck
();
check
=
check
+
(
bottomUpTree
(-
i
,
depth
)).
itemCheck
();
i
=
i
+
1
;
}
/*System.out.println((iterations*2) + "\t trees of depth " + depth + "\t check: " + check);*/
System
.
out
.
println
(
iterations
*
2
);
System
.
out
.
println
(
depth
);
System
.
out
.
println
(
check
);
depth
=
depth
+
2
;
}
/*System.out.println("long lived tree of depth " + maxDepth + "\t check: "+ longLivedTree.itemCheck());*/
System
.
out
.
println
(
maxDepth
);
System
.
out
.
println
(
longLivedTree
.
itemCheck
());
}
public
TreeNode
bottomUpTree
(
int
item
,
int
depth
){
if
(
depth
>
0
){
return
new
TreeNode
().
init2
(
bottomUpTree
(
2
*
item
-
1
,
depth
-
1
)
,
bottomUpTree
(
2
*
item
,
depth
-
1
)
,
item
);
}
else
{
return
new
TreeNode
().
init
(
item
);
}
}
}
class
TreeNode
{
public
TreeNode
left
;
public
TreeNode
right
;
public
int
item
;
public
TreeNode
init
(
int
item
){
this
.
item
=
item
;
return
this
;
}
public
TreeNode
init2
(
TreeNode
left
,
TreeNode
right
,
int
item
){
this
.
left
=
left
;
this
.
right
=
right
;
this
.
item
=
item
;
return
this
;
}
public
int
itemCheck
(){
if
(
left
==
null
)
return
item
;
else
return
item
+
left
.
itemCheck
()
-
right
.
itemCheck
();
}
}
exec/bench_conways_game_of_life.inputc
0 → 100644
View file @
67310848
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
\ No newline at end of file
exec/bench_conways_game_of_life.java
0 → 100644
View file @
67310848
/*
* conways_game_of_life.mj -- Plays Conway's Game of Life.
*
* This is a simulator for Conway's Game of Life [1]. To get the maximum fun
* out of it, you need a video terminal that understands ANSI escape sequences.
* Then, piping the output of this program through a filter as explained in
* `hello_world.mj` will show you a fancy animation of the game. If you cannot
* get access to a terminal (emulator) that is capable of this, you can set the
* variable `HAVE_ANSI` near the beginning of `main` to `false`. Then, the
* output will not use ANSI escape codes but look rather sad. You'll probably
* also want to reduce the iteration count in this case. Here are all
* variables that you might want to tweak.
*
* - `HAVE_ANSI` -- whether ANSI escape codes are supported by the terminal
* - `LINES` -- number of lines available on the terminal
* - `COLUMNS` -- number of columns available on the terminal
* - `ITERATIONS` -- number of iterations to play
* - `RANDOM_SEED` -- random seed for initializing the game
*
* Since MiniJava has no way to suspend, this program deliberately uses an
* inefficient strategy to print the output (knowing that terminals are
* *really* slow at interpreting ANSI escape codes). This means that the
* program will eat all your CPU while it is running. The update rate is about
* alright on my PC but if your computer is much faster or much slower, you
* might not enjoy the animation very much.
*
* [1] https://en.wikipedia.org/wiki/Conway's_Game_of_Life
*
*/
class
CWGOLMain
{
public
static
void
main
(
String
[]
args
)
throws
Exception
{
boolean
HAVE_ANSI
=
true
;
int
LINES
=
24
;
int
COLUMNS
=
80
;
int
ITERATIONS
=
50000
;
int
RANDOM_SEED
=
System
.
in
.
read
();
Game
g
=
new
Game
();
g
.
init
(
LINES
-
2
,
COLUMNS
/
2
-
1
);
LCG
lcg
=
new
LCG
();
lcg
.
init
(
RANDOM_SEED
);
int
i
=
0
;
while
(
i
<
g
.
rows
())
{
int
j
=
0
;
while
(
j
<
g
.
columns
())
{
if
(
lcg
.
next
()
%
8
==
0
)
{
g
.
set
(
i
,
j
);
}
j
=
j
+
1
;
}
i
=
i
+
1
;
}
BoardPrinter
bp
=
new
BoardPrinter
();
bp
.
init
();
if
(
HAVE_ANSI
)
{