int
main (int na, char **av)
{
struct xpr x;
int i;
char buffer[BUFF_SIZE];
struct xoutflags ofs;
unsigned long n;
FILE *fp;
if (na != 2)
{
printf ("para: input_file\n");
exit (-1);
}
fp = fopen (*++av, "r");
printf (" Test of Special Printing Functions\n");
while (fgets (buffer, BUFF_SIZE, fp) != NULL)
{
for (i = 0; buffer[i] != '\0'; i++);
if (i > 0 && buffer[i - 1] == '\n')
buffer[i - 1] = '\0';
if (buffer[0] == '*')
{
getflags (buffer + 1, &ofs);
printf ("* %hi %hi %hi %hi %c\n",
ofs.notat, ofs.sf, ofs.mfwd, ofs.lim, ofs.padding);
}
else
{
printf ("buffer : %s\n", buffer);
x = atox (buffer);
printf ("\t\t <%2d>\n", xfout (stdout, ofs, x));
printf ("\t\t <%2d>\n", xout (ofs, x));
n = xsout (buffer, 20, ofs, x);
printf ("%s\t\t <%2lu>\n", buffer, n);
}
}
fclose (fp);
return 0;
}
int main (int argc,const char *argv[])
{
CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
assert(argc == 2);
std::ofstream xml(argv[1]);
CppUnit::TestResult controller;
CppUnit::TestResultCollector result;
controller.addListener( &result );
CppUnit::TestRunner runner;
runner.addTest(suite);
runner.run(controller);
CppUnit::XmlOutputter xout( &result, xml );
CppUnit::CompilerOutputter tout( &result, std::cout);
xout.write();
tout.write();
return result.wasSuccessful() ? 0 : 1 ;
}
bool simplex_method(void)
{ bool ok = true;
typedef CppAD::vector<double> vector;
double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
//
size_t n = 3;
size_t m = 2;
vector A(m * n), b(m), c(n), xout(n);
A[ 0 * n + 0 ] = 1.0; // A(0,0)
A[ 0 * n + 1 ] = -1.0; // A(0,1)
A[ 0 * n + 2 ] = -1.0; // A(0,2)
//
A[ 1 * n + 0 ] = -1.0; // A(1,0)
A[ 1 * n + 1 ] = +1.0; // A(1,1)
A[ 1 * n + 2 ] = -1.0; // A(1,2)
//
b[0] = -1.0;
b[1] = 1.0;
//
c[0] = 0.0;
c[1] = 0.0;
c[2] = 1.0;
//
size_t maxitr = 10;
size_t level = 0;
//
ok &= CppAD::simplex_method(level, A, b, c, maxitr, xout);
//
// check optimal value for u
ok &= std::fabs( xout[0] - 1.0 ) < eps99;
//
// check optimal value for v
ok &= std::fabs( xout[1] ) < eps99;
//
return ok;
}
//---------------------------------------------------------
DMat& NDG2D::ConformingHrefine2D(IMat& edgerefineflag, const DMat& Qin)
//---------------------------------------------------------
{
#if (0)
OutputNodes(false); // volume nodes
//OutputNodes(true); // face nodes
#endif
// function newQ = ConformingHrefine2D(edgerefineflag, Q)
// Purpose: apply edge splits as requested by edgerefineflag
IVec v1("v1"), v2("v2"), v3("v3"), tvi;
DVec x1("x1"), x2("x2"), x3("x3"), y1("y1"), y2("y2"), y3("y3");
DVec a1("a1"), a2("a2"), a3("a3");
// count vertices
assert (VX.size() == Nv);
// find vertex triplets for elements to be refined
v1 = EToV(All,1); v2 = EToV(All,2); v3 = EToV(All,3);
x1 = VX(v1); x2 = VX(v2); x3 = VX(v3);
y1 = VY(v1); y2 = VY(v2); y3 = VY(v3);
// find angles at each element vertex (in radians)
VertexAngles(x1,x2,x3,y1,y2,y3, a1,a2,a3);
// absolute value of angle size
a1.set_abs(); a2.set_abs(); a3.set_abs();
int k=0,k1=0,f1=0,k2=0,f2=0, e1=0,e2=0,e3=0, b1=0,b2=0,b3=0, ref=0;
IVec m1,m2,m3; DVec mx1, my1, mx2, my2, mx3, my3;
// create new vertices at edge centers of marked elements
// (use unique numbering derived from unique edge number))
m1 = max(IVec(Nv*(v1-1)+v2+1), IVec(Nv*(v2-1)+v1+1)); mx1=0.5*(x1+x2); my1=0.5*(y1+y2);
m2 = max(IVec(Nv*(v2-1)+v3+1), IVec(Nv*(v3-1)+v2+1)); mx2=0.5*(x2+x3); my2=0.5*(y2+y3);
m3 = max(IVec(Nv*(v1-1)+v3+1), IVec(Nv*(v3-1)+v1+1)); mx3=0.5*(x3+x1); my3=0.5*(y3+y1);
// ensure that both elements sharing an edge are split
for (k1=1; k1<=K; ++k1) {
for (f1=1; f1<=Nfaces; ++f1) {
if (edgerefineflag(k1,f1)) {
k2 = EToE(k1,f1);
f2 = EToF(k1,f1);
edgerefineflag(k2,f2) = 1;
}
}
}
// store old data
IMat oldEToV = EToV; DVec oldVX = VX, oldVY = VY;
// count the number of elements in the refined mesh
int newK = countrefinefaces(edgerefineflag);
EToV.resize(newK, Nfaces, true, 0);
IMat newBCType(newK,3, "newBCType");
// kold = [];
IVec kold(newK, "kold"); Index1D KI,KIo;
int sk=1, skstart=0, skend=0;
for (k=1; k<=K; ++k)
{
skstart = sk;
e1 = edgerefineflag(k,1); b1 = BCType(k,1);
e2 = edgerefineflag(k,2); b2 = BCType(k,2);
e3 = edgerefineflag(k,3); b3 = BCType(k,3);
ref = e1 + 2*e2 + 4*e3;
switch (ref) {
case 0:
EToV(sk, All) = IVec(v1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, b3); ++sk;
break;
case 1:
EToV(sk, All) = IVec(v1(k),m1(k),v3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk;
EToV(sk, All) = IVec(m1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
break;
case 2:
EToV(sk, All) = IVec(v2(k),m2(k),v1(k)); newBCType(sk,All) = IVec(b2, 0, b1); ++sk;
EToV(sk, All) = IVec(m2(k),v3(k),v1(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk;
break;
case 4:
EToV(sk, All) = IVec(v3(k),m3(k),v2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk;
EToV(sk, All) = IVec(m3(k),v1(k),v2(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk;
break;
case 3:
EToV(sk, All) = IVec(m1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
if (a1(k) > a3(k)) { // split largest angle
EToV(sk, All) = IVec(v1(k),m1(k),m2(k)); newBCType(sk,All) = IVec(b1, 0, 0); ++sk;
EToV(sk, All) = IVec(v1(k),m2(k),v3(k)); newBCType(sk,All) = IVec( 0, b2, b3); ++sk;
} else {
EToV(sk, All) = IVec(v3(k),m1(k),m2(k)); newBCType(sk,All) = IVec( 0, 0, b2); ++sk;
EToV(sk, All) = IVec(v3(k),v1(k),m1(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk;
}
break;
case 5:
EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk;
if (a2(k) > a3(k)) {
// split largest angle
EToV(sk, All) = IVec(v2(k),m3(k),m1(k)); newBCType(sk,All) = IVec( 0, 0, b1); ++sk;
EToV(sk, All) = IVec(v2(k),v3(k),m3(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk;
} else {
EToV(sk, All) = IVec(v3(k),m3(k),m1(k)); newBCType(sk,All) = IVec(b3, 0, 0); ++sk;
EToV(sk, All) = IVec(v3(k),m1(k),v2(k)); newBCType(sk,All) = IVec( 0, b1, b2); ++sk;
}
break;
case 6:
EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk;
if (a1(k) > a2(k)) {
// split largest angle
EToV(sk, All) = IVec(v1(k),m2(k),m3(k)); newBCType(sk,All) = IVec( 0, 0, b3); ++sk;
EToV(sk, All) = IVec(v1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
} else {
EToV(sk, All) = IVec(v2(k),m2(k),m3(k)); newBCType(sk,All) = IVec(b2, 0, 0); ++sk;
EToV(sk, All) = IVec(v2(k),m3(k),v1(k)); newBCType(sk,All) = IVec( 0 , b3, b1); ++sk;
}
break;
default:
// split all
EToV(sk, All) = IVec(m1(k),m2(k),m3(k)); newBCType(sk, All) = IVec( 0, 0, 0); ++sk;
EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk, All) = IVec(b1, 0, b3); ++sk;
EToV(sk, All) = IVec(v2(k),m2(k),m1(k)); newBCType(sk, All) = IVec(b2, 0, b1); ++sk;
EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk, All) = IVec(b3, 0, b2); ++sk;
break;
}
skend = sk;
// kold = [kold; k*ones(skend-skstart, 1)];
// element k is to be refined into (1:4) child elements.
// store parent element numbers in array "kold" to help
// with accessing parent vertex data during refinement.
KI.reset(skstart, skend-1); // ids of child elements
kold(KI) = k; // mark as children of element k
}
// Finished with edgerefineflag. Delete if OBJ_temp
if (edgerefineflag.get_mode() == OBJ_temp) {
delete (&edgerefineflag);
}
// renumber new nodes contiguously
// ids = unique([v1;v2;v3;m1;m2;m3]);
bool unique=true; IVec IDS, ids;
IDS = concat( concat(v1,v2,v3), concat(m1,m2,m3) );
ids = sort(IDS, unique);
Nv = ids.size();
int max_id = EToV.max_val();
umMSG(1, "max id in EToV is %d\n", max_id);
// M N nnz vals triplet
CSi newids(max_id,1, Nv, 1, 1 );
// newids = sparse(max(max(EToV)),1);
int i=0, j=1;
for (i=1; i<=Nv; ++i) {
// newids(ids)= (1:Nv);
newids.set1(ids(i),j, i); // load 1-based triplets
} // row col x
newids.compress(); // convert to csc form
// Matlab -----------------------------------------------
// v1 = newids(v1); v2 = newids(v2); v3 = newids(v3);
// m1 = newids(m1); m2 = newids(m2); m3 = newids(m3);
//-------------------------------------------------------
int KVi=v1.size(), KMi=m1.size();
// read from copies, overwrite originals
// 1. reload ids for new vertices
tvi = v1; for (i=1;i<=KVi;++i) {v1(i) = newids(tvi(i), 1);}
tvi = v2; for (i=1;i<=KVi;++i) {v2(i) = newids(tvi(i), 1);}
tvi = v3; for (i=1;i<=KVi;++i) {v3(i) = newids(tvi(i), 1);}
// 2. load ids for new (midpoint) vertices
tvi = m1; for (i=1;i<=KMi;++i) {m1(i) = newids(tvi(i), 1);}
tvi = m2; for (i=1;i<=KMi;++i) {m2(i) = newids(tvi(i), 1);}
tvi = m3; for (i=1;i<=KMi;++i) {m3(i) = newids(tvi(i), 1);}
VX.resize(Nv); VY.resize(Nv);
VX(v1) = x1; VX(v2) = x2; VX(v3) = x3;
VY(v1) = y1; VY(v2) = y2; VY(v3) = y3;
VX(m1) = mx1; VX(m2) = mx2; VX(m3) = mx3;
VY(m1) = my1; VY(m2) = my2; VY(m3) = my3;
if (newK != (sk-1)) {
umERROR("NDG2D::ConformingHrefine2D", "Inconsistent element count: expect %d, but sk = %d", newK, (sk-1));
} else {
K = newK; // sk-1;
}
// dumpIMat(EToV, "EToV (before)");
// EToV = newids(EToV);
for (j=1; j<=3; ++j) {
for (k=1; k<=K; ++k) {
EToV(k,j) = newids(EToV(k,j), 1);
}
}
#if (0)
dumpIMat(EToV, "EToV (after)");
// umERROR("Checking ids", "Nigel, check EToV");
#endif
BCType = newBCType;
Nv = VX.size();
// xold = x; yold = y;
StartUp2D();
#if (1)
OutputNodes(false); // volume nodes
//OutputNodes(true); // face nodes
//umERROR("Exiting early", "Check adapted {volume,face} nodes");
#endif
// allocate return object
int Nfields = Qin.num_cols();
DMat* tmpQ = new DMat(Np*K, Nfields, "newQ", OBJ_temp);
DMat& newQ = *tmpQ; // use a reference for syntax
// quick return, if no interpolation is required
if (Qin.size()<1) {
return newQ;
}
DVec rOUT(Np),sOUT(Np),xout,yout,xy1(2),xy2(2),xy3(2),tmp(2),rhs;
int ko=0,kv1=0,kv2=0,kv3=0,n=0; DMat A(2,2), interp;
DMat oldQ = const_cast<DMat&>(Qin);
for (k=1; k<=K; ++k)
{
ko = kold(k); xout = x(All,k); yout = y(All,k);
kv1=oldEToV(ko,1); kv2=oldEToV(ko,2); kv3=oldEToV(ko,3);
xy1.set(oldVX(kv1), oldVY(kv1));
xy2.set(oldVX(kv2), oldVY(kv2));
xy3.set(oldVX(kv3), oldVY(kv3));
A.set_col(1, xy2-xy1); A.set_col(2, xy3-xy1);
for (i=1; i<=Np; ++i) {
tmp.set(xout(i), yout(i));
rhs = 2.0*tmp - xy2 - xy3;
tmp = A|rhs;
rOUT(i) = tmp(1);
sOUT(i) = tmp(2);
}
KI.reset (Np*(k -1)+1, Np*k ); // nodes in new element k
KIo.reset(Np*(ko-1)+1, Np*ko); // nodes in old element ko
interp = Vandermonde2D(N, rOUT, sOUT)*invV;
for (n=1; n<=Nfields; ++n)
{
//newQ(:,k,n)= interp* Q(:,ko,n);
//DVec tm1 = interp*oldQ(KIo,n);
//dumpDVec(tm1, "tm1");
newQ(KI,n) = interp*oldQ(KIo,n);
}
}
return newQ;
}
void CROM_decoder::run() {
double n = static_cast<double> (x_dim);
double logn = log(n);
int long_logn = static_cast<int> (logn);
int half_len = x_dim/2;
int x_start_idx = 0;
int theta_start_idx = 0;
int mat_idx;
int x_hat_idx;
std::vector<double> thetas_inv(half_len);
std::vector<double> xout(x_dim);
double scale = sqrt(n*(1-exp(-2*log(n)/n)));
double scale_factor= exp(-log(n)/n);
double uni_rand;
// at i-th iterationof
// scale = [sqrt(n*(1-exp(-2*R/rawL))) * exp(-i*R/rawL)
// R/L = log(n)/n
int iter_idx;
int theta_idx;
int m;
double l2norm;
// setup scale
scale = sqrt(n*(1-exp(-2*log(n)/n))) * exp(-(L-1)*log(n)/n);
// Set random seed for thetas
fftw_plan p;
p = fftw_plan_r2r_1d(x_dim, x_hat.data(), xout.data(), FFTW_REDFT01, FFTW_MEASURE);
for (iter_idx=L-1; iter_idx>=0; iter_idx--) {
if (verbose) {
printf("iteration = %d\n", iter_idx);
}
mat_idx = iter_idx % long_logn;
// Decoding step
m = m_array[iter_idx];
step(scale, m);
// unnormalize before idct2
unnormalize_vector(x_hat, x_dim);
// run idct2
fftw_execute(p);
// copy x_hat from xout
copy_vector(x_hat, xout, x_dim);
// generate thetas for decoder (sign=false) from random seed=iter_idx
generate_theta_from_seed(thetas_inv, half_len, iter_idx, false);
// multiply inverse butterfly matrix
butterfly_matrix_multiplication(x_hat,
thetas_inv,
half_len,
x_start_idx,
theta_start_idx,
mat_idx);
// update scale with scale factor
scale /= scale_factor;
if (verbose) {
print_vector(x_hat, x_dim);
}
}
fftw_destroy_plan(p);
}
void TestRootBoard::generateCaptures() {
QTextStream xout(stderr);
cpu_set_t mask;
CPU_ZERO( &mask );
CPU_SET( 1, &mask );
if ( sched_setaffinity( 0, sizeof(mask), &mask ) == -1 )
qDebug() << "Could not set CPU Affinity" << endl;
static const unsigned testCases = 200;
static const int iter = 10000;
typedef QVector<uint64_t> Sample;
QVector<Sample> times(testCases, Sample(iter));
QVector<Sample> movetimes(testCases, Sample(iter));
QVector<Sample> captimes(testCases, Sample(iter));
QVector<Sample> b02flood(testCases, Sample(iter));
QVector<Sample> b02point(testCases, Sample(iter));
QVector<Sample> b02double(testCases, Sample(iter));
Move moveList[256];
uint64_t sum=0;
uint64_t movesum=0;
uint64_t nmoves=0;
uint64_t ncap =0;
uint64_t a, d, tsc;
Key blah;
Colors color[testCases];
double cpufreq = 3900.0;
for (unsigned int i = testCases; i;) {
--i;
b->setup(testPositions[i]);
color[i] = b->color;
if (i) {
b->boards[i] = b->boards[0]; }
movetimes[i].reserve(iter*2);
times[i].reserve(iter*2);
captimes[i].reserve(iter*2); }
unsigned op = 1;
const unsigned int iter2 = 10000000;
__v2di res = _mm_set1_epi64x(0);
uint64_t time=0;
#ifdef NDEBUG
for (unsigned int i = 0; i < iter2; ++i) {
Board& bb = b->boards[i & 0xf].wb;
tsc = readtsc();
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build02Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
time += readtsc() - tsc;
// op = fold(res) & 0x3f;
}
std::cout << "build02(pos): " << time/iter2 << " clocks" << std::endl;
time=0;
for (unsigned int i = 0; i < iter2; ++i) {
Board& bb = b->boards[i & 0xf].wb;
tsc = readtsc();
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
res = bb.build13Attack(op);
op = _mm_cvtsi128_si64(res) & 0x3f;
time += readtsc() - tsc; }
std::cout << "build13(pos): " << time/iter2 << " clocks" << std::endl;
// time=0;
// for (unsigned int i = 0; i < iter2; ++i) {
// BoardBase& bb = b->boards[i & 0xf].wb;
// tsc = readtsc();
// res = bb.build02Attack(res);
// time += readtsc() - tsc;
// }
// std::cout << "build02(vector): " << time/iter2 << " clocks" << std::endl;
time=0;
for (unsigned int i = 0; i < iter2; ++i) {
Board& bb = b->boards[i & 0xf].wb;
tsc = readtsc();
res = b->boards[0].wb.build13Attack(res);
res = b->boards[1].wb.build13Attack(res);
res = b->boards[2].wb.build13Attack(res);
res = b->boards[3].wb.build13Attack(res);
res = b->boards[4].wb.build13Attack(res);
res = b->boards[5].wb.build13Attack(res);
res = b->boards[6].wb.build13Attack(res);
res = b->boards[7].wb.build13Attack(res);
time += readtsc() - tsc; }
std::cout << "build13(vector): " << time/iter2 << " clocks" << std::endl;
for (int j = 0; j < iter; ++j) {
nmoves = 0;
ncap=0;
for (unsigned int i = 0; i < testCases; ++i) {
// b->setup(testPositions[i]);
uint64_t overhead;
/*
asm volatile("cpuid\n rdtsc" : "=a" (a), "=d" (d) :: "%rbx", "%rcx");
tsc = (a + (d << 32));
asm volatile("cpuid\n rdtsc" : "=a" (a), "=d" (d) :: "%rbx", "%rcx");
overhead = (a + (d << 32)) - tsc;
*/
overhead = 20;
if (color[i] == White)
b->boards[i].wb.buildAttacks();
else
b->boards[i].bb.buildAttacks();
tsc = readtsc();
Move* good = moveList+192;
Move* bad = good;
if (color[i] == White)
b->boards[i].wb.generateCaptureMoves<AllMoves>(good, bad);
else
b->boards[i].bb.generateCaptureMoves<AllMoves>(good, bad);
ncap += bad - good;
captimes[i][j] = readtsc() - tsc - overhead;
tsc = readtsc();
if (color[i] == White)
b->boards[i].wb.generateNonCap(good, bad);
else
b->boards[i].bb.generateNonCap(good, bad);
nmoves += bad - good;
times[i][j] = readtsc() - tsc - overhead;
for (Move* k=good; k<bad; ++k) {
// std::cout << k->string() << std::endl;
tsc = readtsc();
if (color[i] == White) {
__v8hi est = b->boards[i].b->eval.estimate(wb, *k);
ColoredBoard<Black> bb(b->boards[i].wb, *k, est);
blah += bb.getZobrist(); }
else {
__v8hi est = b->boards[i].b->eval.estimate(bb, *k);
ColoredBoard<White> bb(b->boards[i].bb, *k, est);
blah += bb.getZobrist(); }
movetimes[i][j] += readtsc() - tsc - overhead; }
// std::string empty;
// std::cin >> empty;
} }
for (QVector<Sample>::Iterator i = times.begin(); i != times.end(); ++i) {
qSort(*i);
sum += (*i)[iter / 2]; }
uint64_t capsum=0;
for (QVector<Sample>::Iterator i = captimes.begin(); i != captimes.end(); ++i) {
qSort(*i);
capsum += (*i)[iter / 2]; }
for (QVector<Sample>::Iterator i = movetimes.begin(); i != movetimes.end(); ++i) {
qSort(*i);
movesum += (*i)[iter / 2]; }
xout << endl << nmoves << " Moves, " << sum/nmoves << " Clocks, " << cpufreq* nmoves/sum << " generated Mmoves/s, " << cpufreq* nmoves/movesum << " executed Mmoves/s" << endl;
xout << ncap << " Captures, " << capsum/ncap << " Clocks, " << cpufreq* ncap/capsum << " generated Mmoves/s, " /*<< cpufreq*ncap/movesum << " executed Mmoves/s" */<< endl;
xout << blah + fold(res) + op64 << endl;
#endif
}