int main(){
std::default_random_engine gen(std::chrono::system_clock::now().time_since_epoch().count());
std::uniform_int_distribution<int> dis1(0,3);
std::uniform_int_distribution<int> dis2(0,100);
Queue q1;
std::queue<int> q2;
int m = 1000000;
for(int i=0;i<m;++i){
if(q1.empty()!=q2.empty()){
cout<<"incorrect"<<endl;
break;
}
if(q1.empty() || dis1(gen)<2){
int v = dis2(gen);
q1.push(v);
q2.push(v);
}else{
if(q1.peek()!=q2.front()){
cout<<"incorrect"<<endl;
break;
}
q1.pop();
q2.pop();
}
}
return 0;
}
//--------------------------------------------------------------------
void dice(int ots)
{
if(ots>=1&&ots<=6)//deturmans if onetosix is a valid dise size
{
dis1();// -----
switch (ots)
{
case 1:
// -----
dis5();//| |
dis6();//| * |
dis5();//| |
// -----
break;
case 2:
// -----
dis3();//|* |
dis5();//| |
dis4();//| *|
// -----
break;
case 3:
// -----
dis3();//|* |
dis6();//| * |
dis4();//| *|
// -----
break;
case 4:
// -----
dis2();//|* *|
dis5();//| |
dis2();//|* *|
// -----
break;
case 5:
// -----
dis2();//|* *|
dis6();//| * |
dis2();//|* *|
// -----
break;
case 6:
// -----
dis2();//|* *|
dis2();//|* *|
dis2();//|* *|
// -----
break;
default:
dis1();// -----
}
dis1();
cout<<endl;
}
else
cout<<"Not a valid side"<<endl;
}
SudokuFile& SudokuBoardGenerator::generateBoard(int N, int p, int q, int numAssignments, long timeout) {
//given a SudokuFile with N, P, Q, creates a board with the given params
//and assigns it to the board of the SudokuFile.
//timeout represents the time in ms allowed to created the SudokuFile
SudokuFile sf = SudokuFile(N, p, q);
std::vector<std::vector<int>> tempBoard = sf.getBoard();
if (numAssignments > sf.getN()*sf.getN())
{
std::cout << "Number of assignments exceeds available spaces in board. Returning SudokuFile with an empty board" << std::endl;
return sf;
}
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis1(0, sf.getN() - 1);
std::uniform_int_distribution<> dis2(1, sf.getN());
auto startTime = std::chrono::high_resolution_clock::now();
for (int i = 0; i < numAssignments; i++)
{
int randomRow = dis1(gen); //0 to N-1
int randomColumn = dis1(gen); //0 to N-1
int randomAssignment = dis2(gen); //1 to N
if (tempBoard[randomRow][randomColumn] == 0 && checkConstraints(randomRow, randomColumn, randomAssignment, sf, tempBoard))
{
tempBoard[randomRow][randomColumn] = randomAssignment;
}
else
{
i--;
auto currentTime = std::chrono::high_resolution_clock::now();
if (std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - startTime).count() > timeout)
{
std::cout << "Timeout at " << i << " elements" << std::endl;
std::vector<std::vector<int>> tempboard;
break;
}
}
}
sf.setBoard(tempBoard);
retBoard = tempBoard;
return sf;
}
int
sim_proper(core_t *core, const field_t * const war_pos_tab, unsigned int *death_tab )
{
/*
* Core and Process queue memories.
*
* The warriors share a common cyclic buffer for use as a process
* queue which the contains core addresses where active processes
* are. The buffer has size N*P+1, where N = number of warriors,
* P = maximum number of processes / warrior.
*
* Each warrior has a fixed slice of the buffer for its own process
* queue which are initially allocated to the warriors in reverse
* order. i.e. if the are N warriors w1, w2, ..., wN, the slice for
* wN is 0..P-1, w{N-1} has P..2P-1, until w1 has (N-1)P..NP-1.
*
* The core address of the instruction is fetched from the head of
* the process queue and processes are pushed to the tail, so the
* individual slices slide along at one location per executed
* instruction. The extra '+1' in the buffer size is to have free
* space to slide the slices along.
*
* For two warriors w1, w2:
*
* |\......../|\......../| |
* | w2 queue | w1 queue | |
* 0 P 2P 2P+1
*/
/*
* Cache Registers.
*
* The '94 draft specifies that the redcode processor model be
* 'in-register'. That is, the current instruction and the
* instructions at the effective addresses (ea's) be cached in
* registers during instruction execution, rather than have
* core memory accessed directly when the operands are needed. This
* causes differences from the 'in-memory' model. e.g. MOV 0,>0
* doesn't change the instruction's b-field since the instruction at
* the a-field's effective address (i.e. the instruction itself) was
* cached before the post-increment happened.
*
* There are conceptually three registers: IN, A, and B. IN is the
* current instruction, and A, B are the ones at the a- and
* b-fields' effective addresses respectively.
*
* We don't actually cache the complete instructions, but rather
* only the *values* of their a- and b-field. This is because
* currently there is no way effective address computations can
* modify the opcode, modifier, or addressing modes of an
* instruction.
*/
/*
* misc.
*/
insn_t* const coreptr = core->Core_Mem;
insn_t** const queue_start = core->Queue_Mem;
insn_t** const queue_end = core->Queue_Mem + core->NWarriors*core->Processes+1;
w_t* w; /* current warrior */
const unsigned int coresize = core->Coresize;
const unsigned int coresize1 = coresize-1; /* size of core, size of core - 1 */
insn_t* const CoreEnd = coreptr + coresize; // point after last instruction
insn_t* const CoreEnd1 = CoreEnd - 1; // point to last instruction
int cycles = core->NWarriors * core->Cycles; /* set instruction executions until tie counter */
int alive_cnt = core->NWarriors;
int max_alive_proc = core->NWarriors * core->Processes;
insn_t **pofs = queue_end-1;
#if DEBUG >= 1
insn_t insn; /* used for disassembly */
char debug_line[256]; /* ditto */
#endif
core->War_Tab[0].succ = &core->War_Tab[core->NWarriors-1];
core->War_Tab[core->NWarriors-1].pred = &core->War_Tab[0];
{
u32_t ftmp = 0; /* temps */
do {
int t = core->NWarriors-1-ftmp;
if ( t > 0 ) core->War_Tab[t].succ = &(core->War_Tab[t-1]);
if ( t < core->NWarriors-1 ) core->War_Tab[t].pred = &(core->War_Tab[t+1]);
pofs -= core->Processes;
*pofs = &(coreptr[war_pos_tab[ftmp]]);
core->War_Tab[t].head = pofs;
core->War_Tab[t].tail = pofs+1;
core->War_Tab[t].nprocs = 1;
core->War_Tab[t].id = ftmp;
ftmp++;
} while ( ftmp < core->NWarriors );
}
/*******************************************************************
* Main loop - optimize here
*/
w = &core->War_Tab[ core->NWarriors-1 ];
do {
/* 'in' field of current insn for decoding */
u32_t in;
/* A register values */
u32_t ra_a, ra_b;
/* B register values */
u32_t rb_a, rb_b;
insn_t *pta;
insn_t *ptb;
unsigned int mode;
insn_t* ip = *(w->head);
if ( ++(w->head) == queue_end ) w->head = queue_start;
in = ip->in; /* note: flags must be unset! */
#if !SIM_STRIP_FLAGS
in = in & iMASK; /* strip flags. */
#endif
rb_a = ra_a = ip->a;
rb_b = ip->b;
#if DEBUG >= 1
insn = *ip;
dis1( debug_line, insn, coresize);
#endif
mode = in & mMASK;
/* a-mode calculation */
if (mode == IMMEDIATE) {
/*printf("IMMEDIATE\n");*/
ra_b = rb_b;
pta = ip;
} else if (mode == DIRECT) {
/*printf("DIRECT\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a;
ra_b = pta->b;
} else if (mode == BINDIRECT) {
/*printf("BINDIRECT\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
pta = pta + pta->b; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
} else if (mode == APOSTINC) {
/*printf("APOSTINC\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
{field_t* f = &(pta->a);
pta = pta + pta->a; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
INCMOD(*f);}
} else if (mode == BPOSTINC) {
/*printf("BPOSTINC\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
{field_t* f = &(pta->b);
pta = pta + pta->b; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
INCMOD(*f);}
} else if (mode == APREDEC) {
/*printf("APREDEC\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
DECMOD(pta->a);
pta = pta + pta->a; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
} else if (mode == BPREDEC) {
/*printf("BPREDEC\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
DECMOD(pta->b);
pta = pta + pta->b; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
} else { /* AINDIRECT */
/*printf("AINDIRECT\n");*/
pta = ip + ra_a; if (pta >= CoreEnd) pta -= coresize;
pta = pta + pta->a; if (pta >= CoreEnd) pta -= coresize;
ra_a = pta->a; /* read in registers */
ra_b = pta->b;
}
mode = in & (mMASK<<mBITS);
/* special mov.i code to improve performance */
if ((in & 16320) == (_OP(MOV, mI) << (mBITS*2))) {
if (mode == APREDEC<<mBITS) {
/*++modes[0];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->a);
ptb = ptb + ptb->a; if (ptb >= CoreEnd) ptb -= coresize;
} else if (mode == DIRECT<<mBITS) {
/*++modes[1];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
} else if (mode == APOSTINC<<mBITS) {
/*++modes[2];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
{field_t* f = &(ptb->a);
ptb = ptb + *f; if (ptb >= CoreEnd) ptb -= coresize;
INCMOD(*f);}
} else if (mode == BPREDEC<<mBITS) {
/*++modes[3];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->b);
ptb = ptb + ptb->b; if (ptb >= CoreEnd) ptb -= coresize;
} else if (mode == IMMEDIATE<<mBITS) {
/*++modes[4];*/
ptb = ip;
} else if (mode == BPOSTINC<<mBITS) {
/*++modes[5];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
{field_t* f = &(ptb->b);
ptb = ptb + *f; if (ptb >= CoreEnd) ptb -= coresize;
INCMOD(*f);}
} else if (mode == BINDIRECT<<mBITS) {
/*++modes[6];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
ptb = ptb + ptb->b; if (ptb >= CoreEnd) ptb -= coresize;
} else { /* AINDIRECT */
/*++modes[7];*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
ptb = ptb + ptb->a; if (ptb >= CoreEnd) ptb -= coresize;
}
ptb->a = ra_a;
ptb->b = ra_b;
ptb->in = pta->in;
IPINCMOD(ip);
queue(ip);
goto noqueue;
}
/*15360:
* 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0
* bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
* field | flags | |- op-code -| |-.mod-| |b-mode| |a-mode|
*/
if (!(in & 15360)) {
if (mode == IMMEDIATE<<mBITS) {
} else if (mode == DIRECT<<mBITS) {
} else if (mode == BPOSTINC<<mBITS) {
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
INCMOD(ptb->b);
} else if (mode == BPREDEC<<mBITS) {
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->b);
} else if (mode == APREDEC<<mBITS) {
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->a);
} else if (mode == APOSTINC<<mBITS) {
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
INCMOD(ptb->a);
} /* BINDIRECT, AINDIRECT */
if (in & 512) {
spl:
IPINCMOD(ip);
queue(ip);
if ( w->nprocs < core->Processes ) {
++w->nprocs;
queue(pta);
}
/* in the endgame, check if a tie is inevitable */
if (cycles < max_alive_proc) {
w_t* w_iterator = w->succ;
/* break if all warriors have more processes than cycles */
while ((w_iterator->nprocs * alive_cnt > cycles) && (w_iterator != w)) w_iterator = w_iterator->succ;
if (w_iterator->nprocs*alive_cnt > cycles) {
/*printf("stopping at %d\n", cycles);*/
goto out;
}
}
}
else {
die:
if (--w->nprocs) goto noqueue;
w->pred->succ = w->succ;
w->succ->pred = w->pred;
*death_tab++ = w->id;
cycles = cycles - cycles/alive_cnt; /* nC+k -> (n-1)C+k */
max_alive_proc = alive_cnt * core->Processes;
if ( --alive_cnt <= 1 )
goto out;
}
goto noqueue;
}
/* b-mode calculation */
if (mode == APREDEC<<mBITS) {
/*printf("APREDEC\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->a);
ptb = ptb + ptb->a; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
} else if (mode == DIRECT<<mBITS) {
/*printf("DIRECT\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a;
rb_b = ptb->b;
} else if (mode == APOSTINC<<mBITS) {
/*printf("APOSTINC\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
{field_t* f = &(ptb->a);
ptb = ptb + ptb->a; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
INCMOD(*f);}
} else if (mode == BPREDEC<<mBITS) {
/*printf("BPREDEC\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
DECMOD(ptb->b);
ptb = ptb + ptb->b; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
} else if (mode == IMMEDIATE<<mBITS) {
/*printf("IMMEDIATE\n");*/
ptb = ip;
} else if (mode == BPOSTINC<<mBITS) {
/*printf("BPOSTINC\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
{field_t* f = &(ptb->b);
ptb = ptb + ptb->b; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
INCMOD(*f);}
} else if (mode == BINDIRECT<<mBITS) {
/*printf("BINDIRECT\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
ptb = ptb + ptb->b; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
} else { /* AINDIRECT */
/*printf("AINDIRECT\n");*/
ptb = ip + rb_b; if (ptb >= CoreEnd) ptb -= coresize;
ptb = ptb + ptb->a; if (ptb >= CoreEnd) ptb -= coresize;
rb_a = ptb->a; /* read in registers */
rb_b = ptb->b;
}
#if DEBUG == 2
/* Debug output */
printf("%6d %4ld %s |%4ld, d %4ld,%4ld a %4ld,%4ld b %4ld,%4ld\n",
cycles, ip-core, debug_line,
w->nprocs, pta-core, ptb-core,
ra_a, ra_b, rb_a, rb_b );
#endif
/*
* Execute the instruction on opcode.modifier
*/
switch ( in>>(mBITS*2) ) {
case _OP(MOV, mA):
ptb->a = ra_a;
break;
case _OP(MOV, mF):
ptb->a = ra_a;
case _OP(MOV, mB):
ptb->b = ra_b;
break;
case _OP(MOV, mAB):
ptb->b = ra_a;
break;
case _OP(MOV, mX):
ptb->b = ra_a;
case _OP(MOV, mBA):
ptb->a = ra_b;
break;
case _OP(MOV, mI):
printf("unreachable code reached. You have a problem!\n");
break;
case _OP(DJN,mBA):
case _OP(DJN,mA):
DECMOD(ptb->a);
if ( rb_a == 1 ) break;
queue(pta);
goto noqueue;
case _OP(DJN,mAB):
case _OP(DJN,mB):
DECMOD(ptb->b);
if ( rb_b == 1 ) break;
queue(pta);
goto noqueue;
case _OP(DJN,mX):
case _OP(DJN,mI):
case _OP(DJN,mF):
DECMOD(ptb->a);
DECMOD(ptb->b);
if ( rb_a == 1 && rb_b == 1 ) break;
queue(pta);
goto noqueue;
case _OP(ADD, mI):
case _OP(ADD, mF):
ADDMOD(ptb->b, ra_b, rb_b );
case _OP(ADD, mA):
ADDMOD(ptb->a, ra_a, rb_a );
break;
case _OP(ADD, mB):
ADDMOD(ptb->b, ra_b, rb_b );
break;
case _OP(ADD, mX):
ADDMOD(ptb->a, ra_b, rb_a );
case _OP(ADD, mAB):
ADDMOD(ptb->b, ra_a, rb_b );
break;
case _OP(ADD, mBA):
ADDMOD(ptb->a, ra_b, rb_a );
break;
case _OP(JMZ, mBA):
case _OP(JMZ, mA):
if ( rb_a )
break;
queue(pta);
goto noqueue;
case _OP(JMZ, mAB):
case _OP(JMZ, mB):
if ( rb_b )
break;
queue(pta);
goto noqueue;
case _OP(JMZ, mX):
case _OP(JMZ, mF):
case _OP(JMZ, mI):
if ( rb_a || rb_b )
break;
queue(pta);
goto noqueue;
case _OP(SUB, mI):
case _OP(SUB, mF):
SUBMOD(ptb->b, rb_b, ra_b );
case _OP(SUB, mA):
SUBMOD(ptb->a, rb_a, ra_a);
break;
case _OP(SUB, mB):
SUBMOD(ptb->b, rb_b, ra_b );
break;
case _OP(SUB, mX):
SUBMOD(ptb->a, rb_a, ra_b );
case _OP(SUB, mAB):
SUBMOD(ptb->b, rb_b, ra_a );
break;
case _OP(SUB, mBA):
SUBMOD(ptb->a, rb_a, ra_b );
break;
case _OP(SEQ, mA):
if ( ra_a == rb_a )
IPINCMOD(ip);
break;
case _OP(SEQ, mB):
if ( ra_b == rb_b )
IPINCMOD(ip);
break;
case _OP(SEQ, mAB):
if ( ra_a == rb_b )
IPINCMOD(ip);
break;
case _OP(SEQ, mBA):
if ( ra_b == rb_a )
IPINCMOD(ip);
break;
case _OP(SEQ, mI):
if ( pta->in != ptb->in )
break;
case _OP(SEQ, mF):
if ( ra_a == rb_a && ra_b == rb_b )
IPINCMOD(ip);
break;
case _OP(SEQ, mX):
if ( ra_a == rb_b && ra_b == rb_a )
IPINCMOD(ip);
break;
case _OP(SNE, mA):
if ( ra_a != rb_a )
IPINCMOD(ip);
break;
case _OP(SNE, mB):
if ( ra_b != rb_b )
IPINCMOD(ip);
break;
case _OP(SNE, mAB):
if ( ra_a != rb_b )
IPINCMOD(ip);
break;
case _OP(SNE, mBA):
if ( ra_b != rb_a )
IPINCMOD(ip);
break;
case _OP(SNE, mI):
if ( pta->in != ptb->in ) {
IPINCMOD(ip);
break;
}
/* fall through */
case _OP(SNE, mF):
if ( ra_a != rb_a || ra_b != rb_b )
IPINCMOD(ip);
break;
case _OP(SNE, mX):
if ( ra_a != rb_b || ra_b != rb_a )
IPINCMOD(ip);
break;
case _OP(JMN, mBA):
case _OP(JMN, mA):
if (! rb_a )
break;
queue(pta);
goto noqueue;
case _OP(JMN, mAB):
case _OP(JMN, mB):
if (! rb_b )
break;
queue(pta);
goto noqueue;
case _OP(JMN, mX):
case _OP(JMN, mF):
case _OP(JMN, mI):
if (rb_a || rb_b) {
queue(pta);
goto noqueue;
}
break;
case _OP(JMP, mA):
case _OP(JMP, mB):
case _OP(JMP, mAB):
case _OP(JMP, mBA):
case _OP(JMP, mX):
case _OP(JMP, mF):
case _OP(JMP, mI):
queue(pta);
goto noqueue;
case _OP(SLT, mA):
if (ra_a < rb_a)
IPINCMOD(ip);
break;
case _OP(SLT, mAB):
if (ra_a < rb_b)
IPINCMOD(ip);
break;
case _OP(SLT, mB):
if (ra_b < rb_b)
IPINCMOD(ip);
break;
case _OP(SLT, mBA):
if (ra_b < rb_a)
IPINCMOD(ip);
break;
case _OP(SLT, mI):
case _OP(SLT, mF):
if (ra_a < rb_a && ra_b < rb_b)
IPINCMOD(ip);
break;
case _OP(SLT, mX):
if (ra_a < rb_b && ra_b < rb_a)
IPINCMOD(ip);
break;
case _OP(MODM, mI):
case _OP(MODM, mF):
if ( ra_a ) ptb->a = rb_a % ra_a;
if ( ra_b ) ptb->b = rb_b % ra_b;
if (!ra_a || !ra_b) goto die;
break;
case _OP(MODM, mX):
if ( ra_b ) ptb->a = rb_a % ra_b;
if ( ra_a ) ptb->b = rb_b % ra_a;
if (!ra_b || !ra_a) goto die;
break;
case _OP(MODM, mA):
if ( !ra_a ) goto die;
ptb->a = rb_a % ra_a;
break;
case _OP(MODM, mB):
if ( !ra_b ) goto die;
ptb->b = rb_b % ra_b;
break;
case _OP(MODM, mAB):
if ( !ra_a ) goto die;
ptb->b = rb_b % ra_a;
break;
case _OP(MODM, mBA):
if ( !ra_b ) goto die;
ptb->a = rb_a % ra_b;
break;
case _OP(MUL, mI):
case _OP(MUL, mF):
ptb->b = (rb_b * ra_b) % coresize;
case _OP(MUL, mA):
ptb->a = (rb_a * ra_a) % coresize;
break;
case _OP(MUL, mB):
ptb->b = (rb_b * ra_b) % coresize;
break;
case _OP(MUL, mX):
ptb->a = (rb_a * ra_b) % coresize;
case _OP(MUL, mAB):
ptb->b = (rb_b * ra_a) % coresize;
break;
case _OP(MUL, mBA):
ptb->a = (rb_a * ra_b) % coresize;
break;
case _OP(DIV, mI):
case _OP(DIV, mF):
if ( ra_a ) ptb->a = rb_a / ra_a;
if ( ra_b ) ptb->b = rb_b / ra_b;
if (!ra_a || !ra_b) goto die;
break;
case _OP(DIV, mX):
if ( ra_b ) ptb->a = rb_a / ra_b;
if ( ra_a ) ptb->b = rb_b / ra_a;
if (!ra_b || !ra_a) goto die;
break;
case _OP(DIV, mA):
if ( !ra_a ) goto die;
ptb->a = rb_a / ra_a;
break;
case _OP(DIV, mB):
if ( !ra_b ) goto die;
ptb->b = rb_b / ra_b;
break;
case _OP(DIV, mAB):
if ( !ra_a ) goto die;
ptb->b = rb_b / ra_a;
break;
case _OP(DIV, mBA):
if ( !ra_b ) goto die;
ptb->a = rb_a / ra_b;
break;
case _OP(NOP,mI):
case _OP(NOP,mX):
case _OP(NOP,mF):
case _OP(NOP,mA):
case _OP(NOP,mAB):
case _OP(NOP,mB):
case _OP(NOP,mBA):
break;
case _OP(LDP,mA):
ptb->a = UNSAFE_PSPACE_GET(w->id, ra_a % core->PSpace_size);
break;
case _OP(LDP,mAB):
ptb->b = UNSAFE_PSPACE_GET(w->id, ra_a % core->PSpace_size);
break;
case _OP(LDP,mBA):
ptb->a = UNSAFE_PSPACE_GET(w->id, ra_b % core->PSpace_size);
break;
case _OP(LDP,mF):
case _OP(LDP,mX):
case _OP(LDP,mI):
case _OP(LDP,mB):
ptb->b = UNSAFE_PSPACE_GET(w->id, ra_b % core->PSpace_size);
break;
case _OP(STP,mA):
UNSAFE_PSPACE_SET(w->id, rb_a % core->PSpace_size, ra_a);
break;
case _OP(STP,mAB):
UNSAFE_PSPACE_SET(w->id, rb_b % core->PSpace_size, ra_a);
break;
case _OP(STP,mBA):
UNSAFE_PSPACE_SET(w->id, rb_a % core->PSpace_size, ra_b);
break;
case _OP(STP,mF):
case _OP(STP,mX):
case _OP(STP,mI):
case _OP(STP,mB):
UNSAFE_PSPACE_SET(w->id, rb_b % core->PSpace_size, ra_b);
break;
#if DEBUG > 0
default:
alive_cnt = -1;
goto out;
#endif
}
IPINCMOD(ip);
queue(ip);
noqueue:
w = w->succ;
} while(--cycles > 0);
out:
#if DEBUG == 2
printf("cycles: %d\n", cycles);
#endif
return alive_cnt;
}
