SecondaryStructureResidue setup_coarse_secondary_structure_residue(
const Particles &ssr_ps, Model *mdl,
bool winner_takes_all_per_res) {
Floats scores;
scores.push_back(0.0);
scores.push_back(0.0);
scores.push_back(0.0);
int count = 0;
for (Particles::const_iterator p = ssr_ps.begin(); p != ssr_ps.end();
++p) {
IMP_USAGE_CHECK(SecondaryStructureResidue::get_is_setup(*p),
"all particles must be SecondaryStructureResidues");
SecondaryStructureResidue ssr(*p);
Floats tmp_scores;
tmp_scores.push_back(ssr.get_prob_helix());
tmp_scores.push_back(ssr.get_prob_strand());
tmp_scores.push_back(ssr.get_prob_coil());
int max_i = 0;
Float max = 0.0;
for (int i = 0; i < 3; i++) {
if (tmp_scores[i] > max) {
max = tmp_scores[i];
max_i = i;
}
if (!winner_takes_all_per_res) scores[i] += tmp_scores[i];
}
if (winner_takes_all_per_res) scores[max_i] += 1.0;
count++;
}
IMP_NEW(Particle, coarse_p, (mdl));
SecondaryStructureResidue ssres = SecondaryStructureResidue::setup_particle(
coarse_p, scores[0] / count, scores[1] / count, scores[2] / count);
return ssres;
}
void run() {
Client::WriteContext ctx(&_txn, ns());
setupCollection();
BSONObj filterObj = fromjson("{a: {$gte: 2}}");
scoped_ptr<SingleSolutionRunner> ssr(makeCollScanRunner(ctx.ctx(),filterObj));
BSONObj objOut;
ASSERT_EQUALS(Runner::RUNNER_ADVANCED, ssr->getNext(&objOut, NULL));
ASSERT_EQUALS(2, objOut["a"].numberInt());
forceDocumentMove();
int ids[] = {3, 4, 2};
checkIds(ids, ssr.get());
}
void run() {
Client::WriteContext ctx(&_txn, ns());
setupCollection();
BSONObj indexSpec = BSON("_id" << 1);
addIndex(indexSpec);
BSONObj filterObj = fromjson("{a: {$gte: 2}}");
scoped_ptr<SingleSolutionRunner> ssr(makeIndexScanRunner(ctx.ctx(), indexSpec, 2, 5));
BSONObj objOut;
ASSERT_EQUALS(Runner::RUNNER_ADVANCED, ssr->getNext(&objOut, NULL));
ASSERT_EQUALS(2, objOut["a"].numberInt());
forceDocumentMove();
// Since this time we're scanning the _id index,
// we should not see the moved document again.
int ids[] = {3, 4};
checkIds(ids, ssr.get());
}
void run() {
Client::WriteContext ctx(&_txn, ns());
insert(BSON("_id" << 1));
insert(BSON("_id" << 2));
BSONObj filterObj = fromjson("{_id: {$gt: 0}}");
scoped_ptr<SingleSolutionRunner> ssr(makeCollScanRunner(ctx.ctx(),filterObj));
registerRunner(ssr.get());
BSONObj objOut;
ASSERT_EQUALS(Runner::RUNNER_ADVANCED, ssr->getNext(&objOut, NULL));
ASSERT_EQUALS(1, objOut["_id"].numberInt());
// After dropping the collection, the runner
// should be dead.
dropCollection();
ASSERT_EQUALS(Runner::RUNNER_DEAD, ssr->getNext(&objOut, NULL));
deregisterRunner(ssr.get());
}
void run() {
Client::WriteContext ctx(&_txn, ns());
insert(BSON("_id" << 1 << "a" << 6));
insert(BSON("_id" << 2 << "a" << 7));
insert(BSON("_id" << 3 << "a" << 8));
BSONObj indexSpec = BSON("a" << 1);
addIndex(indexSpec);
scoped_ptr<SingleSolutionRunner> ssr(makeIndexScanRunner(ctx.ctx(), indexSpec, 7, 10));
registerRunner(ssr.get());
BSONObj objOut;
ASSERT_EQUALS(Runner::RUNNER_ADVANCED, ssr->getNext(&objOut, NULL));
ASSERT_EQUALS(7, objOut["a"].numberInt());
// After dropping the collection, the runner
// should be dead.
dropCollection();
ASSERT_EQUALS(Runner::RUNNER_DEAD, ssr->getNext(&objOut, NULL));
deregisterRunner(ssr.get());
}
int main (int argc, char *argv[])
{
args_t args;
struct stat st;
#ifdef WIN
//
PVOID OldValue=NULL;
WSADATA wsa;
Wow64DisableWow64FsRedirection (&OldValue);
WSAStartup(MAKEWORD(2,0), &wsa);
#endif
setbuf(stdout, NULL);
setbuf(stderr, NULL);
memset (&args, 0, sizeof(args));
// set default parameters
args.address = NULL;
args.file = NULL;
args.ai_family = AF_INET;
args.port = DEFAULT_PORT;
args.port_nbr = atoi(args.port);
args.mode = -1;
args.tx_mode = -1;
args.sim = 0;
args.dbg = 0;
printf ("\n[ run shellcode v0.1\n");
parse_args(&args, argc, argv);
// check if we have file parameter and it accessible
if (args.file!=NULL) {
if (stat (args.file, &st)) {
printf ("[ unable to access %s\n", args.file);
return 0;
} else {
if (st.st_size > MAX_BUFSIZ) {
printf ("[ %s exceeds MAX_BUFSIZ of %i bytes\n", args.file, MAX_BUFSIZ);
return 0;
}
}
}
// if mode is executing
if (args.mode==RSC_EXEC) {
if (args.file!=NULL) {
xfile(&args);
return 0;
} else {
printf ("\n[ you've used -x without supplying file with -f");
return 0;
}
}
if (init_network(&args))
{
// if no file specified, we receive and execute data
args.tx_mode = (args.file==NULL) ? RSC_RECV : RSC_SEND;
// if mode is -1, we listen for incoming connections
if (args.mode == -1) {
args.mode=RSC_SERVER;
}
// if no file specified, set to receive one
if (args.tx_mode == -1) {
args.tx_mode=RSC_RECV;
}
if (args.mode==RSC_SERVER) {
ssr (&args);
} else {
csr (&args);
}
}
return 0;
}
void CTestApp::RunSpeedBenchmark(void)
{
NcbiCout << NcbiEndl << "NStr:: String to Double speed tests..."
<< NcbiEndl;
const CArgs& args = GetArgs();
const int COUNT = args["count"].AsInteger();
string test_strings;
if ( args["test_strings"] ) {
test_strings = args["test_strings"].AsString();
}
else {
test_strings = ",0,1,12,123,123456789,1234567890,TRACE,0e9,1e9"
",1.234567890123456789e300,-1.234567890123456789e-300"
",1.234567890123456789e200,-1.234567890123456789e-200";
}
vector<string> ss;
NStr::Tokenize(test_strings, ",", ss);
const size_t TESTS = ss.size();
vector<double> ssr(TESTS), ssr_min(TESTS), ssr_max(TESTS);
static const int kConvertError = -555;
for ( size_t i = 0; i < TESTS; ++i ) {
double r;
try {
r = PreciseStringToDouble(ss[i]);
}
catch ( CException& /*exc*/ ) {
//ERR_POST(exc);
ssr[i] = ssr_min[i] = ssr_max[i] = kConvertError;
continue;
}
ssr[i] = r;
double min, max;
if ( r < 0 ) {
min = r*(1+EPS);
max = r*(1-EPS);
}
else {
min = r*(1-EPS);
max = r*(1+EPS);
}
ssr_min[i] = min;
ssr_max[i] = max;
}
int flags = NStr::fConvErr_NoThrow|NStr::fAllowLeadingSpaces;
double v;
for ( size_t t = 0; t < TESTS; ++t ) {
if ( 1 ) {
errno = 0;
v = NStr::StringToDouble(ss[t], flags|NStr::fDecimalPosix);
if ( errno ) v = kConvertError;
if ( v < ssr_min[t] || v > ssr_max[t] )
ERR_POST(Fatal<<v<<" != "<<ssr[t]<<" for \"" << ss[t] << "\"");
}
if ( 1 ) {
errno = 0;
v = NStr::StringToDouble(ss[t], flags);
if ( errno ) v = kConvertError;
if ( v < ssr_min[t] || v > ssr_max[t] )
ERR_POST(Fatal<<v<<" != "<<ssr[t]<<" for \"" << ss[t] << "\"");
}
if ( 1 ) {
errno = 0;
char* errptr;
v = NStr::StringToDoublePosix(ss[t].c_str(), &errptr);
if ( errno || (errptr&&(*errptr||errptr==ss[t].c_str())) ) v = kConvertError;
if ( v < ssr_min[t] || v > ssr_max[t] )
ERR_POST(Fatal<<v<<" != "<<ssr[t]<<" for \"" << ss[t] << "\"");
}
if ( 1 ) {
errno = 0;
char* errptr;
v = StringToDoublePosixOld(ss[t].c_str(), &errptr);
if ( errno || (errptr&&(*errptr||errptr==ss[t].c_str())) ) v = kConvertError;
if ( v < ssr_min[t] || v > ssr_max[t] )
ERR_POST(Fatal<<v<<" != "<<ssr[t]<<" for \"" << ss[t] << "\"");
}
if ( 1 ) {
errno = 0;
char* errptr;
v = strtod(ss[t].c_str(), &errptr);
if ( errno || (errptr&&(*errptr||errptr==ss[t].c_str())) ) v = kConvertError;
if ( v < ssr_min[t] || v > ssr_max[t] )
ERR_POST(Fatal<<v<<" != "<<ssr[t]<<" for \"" << ss[t] << "\"");
}
}
for ( size_t t = 0; t < TESTS; ++t ) {
NcbiCout << "Testing "<<ss[t]<<":" << endl;
string s1 = ss[t];
CTempStringEx s = ss[t];
const char* s2 = ss[t].c_str();
CStopWatch sw;
double time;
if ( 1 ) {
sw.Restart();
for ( int i = 0; i < COUNT; ++i ) {
errno = 0;
v = NStr::StringToDouble(s, flags|NStr::fDecimalPosix);
if ( errno ) v = kConvertError;
}
time = sw.Elapsed();
NcbiCout << " StringToDouble(Posix): " << time << endl;
}
if ( 1 ) {
sw.Restart();
for ( int i = 0; i < COUNT; ++i ) {
errno = 0;
v = NStr::StringToDouble(s, flags);
if ( errno ) v = kConvertError;
}
time = sw.Elapsed();
NcbiCout << " StringToDouble(): " << time << endl;
}
if ( 1 ) {
sw.Restart();
for ( int i = 0; i < COUNT; ++i ) {
errno = 0;
char* errptr;
v = NStr::StringToDoublePosix(s2, &errptr);
if ( errno || (errptr&&(*errptr||errptr==s2)) ) v = kConvertError;
}
time = sw.Elapsed();
NcbiCout << " StringToDoublePosix(): " << time << endl;
}
if ( 1 ) {
sw.Restart();
for ( int i = 0; i < COUNT; ++i ) {
errno = 0;
char* errptr;
v = StringToDoublePosixOld(s2, &errptr);
if ( errno || (errptr&&(*errptr||errptr==s2)) ) v = kConvertError;
}
time = sw.Elapsed();
NcbiCout << "StringToDoublePosixOld(): " << time << endl;
}
if ( 1 ) {
sw.Restart();
for ( int i = 0; i < COUNT; ++i ) {
errno = 0;
char* errptr;
v = strtod(s2, &errptr);
if ( errno || (errptr&&(*errptr||errptr==s2)) ) v = kConvertError;
}
time = sw.Elapsed();
NcbiCout << " strtod(): " << time << endl;
}
}
}
void SceneObjectEntryPointSurf::onAdd() {
// Physics
std::shared_ptr<pge::SceneObjectPhysicsWorld> physicsWorld(new pge::SceneObjectPhysicsWorld());
getRenderScene()->addNamed(physicsWorld, "physWrld");
pge::SceneObjectRef lighting = getScene()->getNamed("lighting");
pge::SceneObjectLighting* pLighting = static_cast<pge::SceneObjectLighting*>(lighting.get());
pLighting->_ambientLight = pge::Vec3f(0.01f, 0.01f, 0.01f);
/*std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> light(new pge::SceneObjectDirectionalLightShadowed());
getRenderScene()->add(light);
light->create(pLighting, 2, 2048, 0.5f, 100.0f, 0.6f);
light->setDirection(pge::Vec3f(-0.4f, -1.0f, 0.6f).normalized());
light->setColor(pge::Vec3f(1.0f, 1.0f, 1.0f));*/
// GUI
/*std::shared_ptr<SceneObjectGUI> gui(new SceneObjectGUI());
getRenderScene()->addNamed(gui, "gui", false);
gui->_layer = 2.0f;*/
// Control
std::shared_ptr<SceneObjectOrbitCamera> camera(new SceneObjectOrbitCamera());
getRenderScene()->add(camera, false);
// Map
/*std::shared_ptr<pge::Map3DWS> map(new pge::Map3DWS());
map->_settings._pScene = getScene();
map->createAsset("resources/maps/horrorMap.3dw");
pge::addMapLights(*map, getScene());*/
std::shared_ptr<SceneObjectProp> prop(new SceneObjectProp());
getScene()->add(prop, true);
prop->create("resources/models/BlockGame.obj");
prop->calculateAABB();
std::shared_ptr<SceneObjectSurf> cartPole(new SceneObjectSurf());
getRenderScene()->add(cartPole, false);
cartPole->create();
cartPole->_layer = 100.0f;
std::shared_ptr<SceneObjectProp> sky(new SceneObjectProp());
getScene()->add(sky, true);
sky->create("resources/models/skybox1.obj");
sky->_transform = pge::Matrix4x4f::scaleMatrix(pge::Vec3f(100.0f, 100.0f, 100.0f));
sky->calculateAABB();
std::shared_ptr<pge::SceneObjectDirectionalLightShadowed> directionalLight(new pge::SceneObjectDirectionalLightShadowed());
getScene()->add(directionalLight);
directionalLight->create(pLighting, 3, 2048, 0.2f, 100.0f, 0.6f);
directionalLight->setDirection(pge::Vec3f(-0.2523f, -0.9423f, -0.424f).normalized());
directionalLight->setColor(pge::Vec3f(0.7f, 0.7f, 0.7f));
// ------------------------------------------- Image Effects -------------------------------------------
std::shared_ptr<pge::SceneObjectEffectBuffer> effectBuffer(new pge::SceneObjectEffectBuffer());
getRenderScene()->addNamed(effectBuffer, "ebuf", false);
effectBuffer->create(0.5f);
std::shared_ptr<pge::Asset> assetBlurHorizontal;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontal.frag", assetBlurHorizontal);
std::shared_ptr<pge::Shader> blurShaderHorizontal = std::static_pointer_cast<pge::Shader>(assetBlurHorizontal);
std::shared_ptr<pge::Asset> assetBlurVertical;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVertical.frag", assetBlurVertical);
std::shared_ptr<pge::Shader> blurShaderVertical = std::static_pointer_cast<pge::Shader>(assetBlurVertical);
std::shared_ptr<pge::Asset> assetRenderImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImage.frag", assetRenderImage);
std::shared_ptr<pge::Shader> renderImageShader = std::static_pointer_cast<pge::Shader>(assetRenderImage);
std::shared_ptr<pge::Asset> assetRenderMultImage;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/renderImageMult.frag", assetRenderMultImage);
std::shared_ptr<pge::Shader> renderImageMultShader = std::static_pointer_cast<pge::Shader>(assetRenderMultImage);
std::shared_ptr<pge::Asset> assetNoise;
getScene()->getAssetManager("tex2D", pge::Texture2D::assetFactory)->getAsset("resources/textures/noise.bmp", assetNoise);
std::shared_ptr<pge::Texture2D> noiseMap = std::static_pointer_cast<pge::Texture2D>(assetNoise);
noiseMap->bind();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
std::shared_ptr<pge::Asset> assetBlurHorizontalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurHorizontalEdgeAware.frag", assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderHorizontalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurHorizontalEdgeAware);
std::shared_ptr<pge::Asset> assetBlurVerticalEdgeAware;
getScene()->getAssetManager("shader", pge::Shader::assetFactory)->getAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/blurVerticalEdgeAware.frag", assetBlurVerticalEdgeAware);
std::shared_ptr<pge::Shader> blurShaderVerticalEdgeAware = std::static_pointer_cast<pge::Shader>(assetBlurVerticalEdgeAware);
// SSAO
/*std::shared_ptr<pge::Shader> ssaoShader(new pge::Shader());
ssaoShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssao.frag");
std::shared_ptr<pge::SceneObjectSSAO> ssao(new pge::SceneObjectSSAO());
getRenderScene()->add(ssao, false);
ssao->create(blurShaderHorizontal, blurShaderVertical, ssaoShader, renderImageShader, noiseMap);
ssao->_ssaoRadius = 0.1f;
ssao->_ssaoStrength = 1.0f;
ssao->_blurRadius = 0.002f;
ssao->_numBlurPasses = 1;*/
// SSR
std::shared_ptr<pge::TextureCube> cubeMap(new pge::TextureCube());
cubeMap->createAsset(
"resources/environmentmaps/skybox1/CloudyLightRaysLeft2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysRight2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysBack2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysFront2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysDown2048.png "
"resources/environmentmaps/skybox1/CloudyLightRaysUp2048.png "
);
std::shared_ptr<pge::Shader> ssrShader(new pge::Shader());
ssrShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/ssr.frag");
std::shared_ptr<pge::SceneObjectSSR> ssr(new pge::SceneObjectSSR());
getRenderScene()->add(ssr, false);
ssr->create(blurShaderHorizontalEdgeAware, blurShaderVerticalEdgeAware, ssrShader, renderImageShader, cubeMap, noiseMap);
ssr->_layer = 1.0f;
// Light Scattering
/*std::shared_ptr<pge::Shader> lightScatteringShader(new pge::Shader());
lightScatteringShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lightScattering.frag");
std::shared_ptr<pge::SceneObjectLightScattering> lightScattering(new pge::SceneObjectLightScattering());
getRenderScene()->add(lightScattering, false);
lightScattering->create(blurShaderHorizontal, blurShaderVertical, lightScatteringShader, renderImageShader);
lightScattering->_layer = 1.5f;
lightScattering->_lightSourcePosition = -light->getDirection() * 200.0f;
lightScattering->_lightSourceColor = pge::Vec3f(1.0f, 0.9f, 0.8f) * 0.5f;*/
// Depth of field
/*std::shared_ptr<pge::Shader> depthOfFieldBlurShaderHorizontal(new pge::Shader());
depthOfFieldBlurShaderHorizontal->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurHorizontal.frag");
std::shared_ptr<pge::Shader> depthOfFieldBlurShaderVertical(new pge::Shader());
depthOfFieldBlurShaderVertical->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/depthOfFieldBlurVertical.frag");
std::shared_ptr<pge::SceneObjectDepthOfField> depthOfField(new pge::SceneObjectDepthOfField());
getRenderScene()->add(depthOfField, false);
depthOfField->create(depthOfFieldBlurShaderHorizontal, depthOfFieldBlurShaderVertical, renderImageShader);
depthOfField->_layer = 1.5f;
depthOfField->_focalDistance = 9.0f;
depthOfField->_focalRange = 0.4f;
depthOfField->_blurRadius = 0.002f;
depthOfField->_numBlurPasses = 1;*/
// FXAA
std::shared_ptr<pge::Shader> lumaShader(new pge::Shader());
lumaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/lumaRender.frag");
std::shared_ptr<pge::Shader> fxaaShader(new pge::Shader());
fxaaShader->createAsset("NONE resources/shaders/noTransformVertex.vert resources/shaders/imageeffects/fxaa.frag");
std::shared_ptr<pge::SceneObjectFXAA> fxaa(new pge::SceneObjectFXAA());
getRenderScene()->add(fxaa, false);
fxaa->create(fxaaShader, lumaShader);
destroy();
}
void cmp(string rA, string rB)
{
int* regA, regB;
switch (rA)
{
case "$r0":
regA = &genReg[0];
break;
case "$r1":
regA = &genReg[1];
break;
case "$r2":
regA = &genReg[2];
break;
case "$r3":
regA = &genReg[3];
break;
case "$r4":
regA = &genReg[4];
break;
case "$r5":
regA = &genReg[5];
break;
case "$r6":
regA = &genReg[6];
break;
case "$r7":
regA = &genReg[7];
break;
case "$r8":
regA = &genReg[8];
break;
case "$r9":
regA = &genReg[9];
break;
case "$r10":
regA = &genReg[10];
break;
case "$r11":
regA = &genReg[11];
break;
case "$r12":
regA = &genReg[12];
break;
case "$r13":
regA = &genReg[13];
break;
case "0":
regA = &SpecReg[0];
break;
case "1":
regA = &SpecReg[1];
break;
case "2":
regA = &SpecReg[2];
break;
case "3":
regA = &SpecReg[3];
break;
case "4":
regA = &SpecReg[4];
break;
case "5":
regA = &SpecReg[5];
break;
case "6":
regA = &SpecReg[6];
break;
case "7":
regA = &SpecReg[7];
break;
case "8":
regA = &SpecReg[8];
break;
case "9":
regA = &SpecReg[9];
break;
case "$sp":
regA = &sp;
break;
case "$fp":
regA = &fp;
break;
default:
return false;
}
switch (rB)
{
case "$r0":
regB = &genReg[0];
break;
case "$r1":
regB = &genReg[1];
break;
case "$r2":
regB = &genReg[2];
break;
case "$r3":
regB = &genReg[3];
break;
case "$r4":
regB = &genReg[4];
break;
case "$r5":
regB = &genReg[5];
break;
case "$r6":
regB = &genReg[6];
break;
case "$r7":
regB = &genReg[7];
break;
case "$r8":
regB = &genReg[8];
break;
case "$r9":
regB = &genReg[9];
break;
case "$r10":
regB = &genReg[10];
break;
case "$r11":
regB = &genReg[11];
break;
case "$r12":
regB = &genReg[12];
break;
case "$r13":
regB = &genReg[13];
break;
case "0":
regB = &SpecReg[0];
break;
case "1":
regB = &SpecReg[1];
break;
case "2":
regB = &SpecReg[2];
break;
case "3":
regB = &SpecReg[3];
break;
case "4":
regB = &SpecReg[4];
break;
case "5":
regB = &SpecReg[5];
break;
case "6":
regB = &SpecReg[6];
break;
case "7":
regB = &SpecReg[7];
break;
case "8":
regB = &SpecReg[8];
break;
case "9":
regB = &SpecReg[9];
break;
case "$sp":
regB = &sp;
break;
case "$fp":
regB = &fp;
break;
default:
return false;
}
int result = *regA - *regB;
if(result > 0)
ssr(0, 1);
else
if (result == 0)
ssr(0, 2);
else
ssr(0, 0);
}
