int main(int argc, char *argv[]) {
    struct timeval start, stop;
    string file = argv[1];

    char *l_returnflag = new char[Q1_LINEITEM];
    char *l_linestatus = new char[Q1_LINEITEM];
    float *l_quantity = new float[Q1_LINEITEM];
    float *l_extendedprice = new float[Q1_LINEITEM];
    float *l_discount = new float[Q1_LINEITEM];
    float *l_tax = new float[Q1_LINEITEM];
    long *l_shipdate = new long[Q1_LINEITEM];
    init(file, l_returnflag, l_linestatus, l_quantity, l_extendedprice,
            l_discount, l_tax, l_shipdate);
    unordered_map<short,char *> *vals = new unordered_map<short,char *>();

    test(vals);
    gettimeofday(&start, NULL);
    for (int i = 0; i < Q1_LINEITEM; i++)
        if (pred1(l_shipdate[i])) {
            short key = getKey(l_returnflag[i], l_linestatus[i]);
            char *val = getVal(vals, key, l_returnflag[i], l_linestatus[i]);
            *((int *) (val + 2)) += 1;
            *((float *) (val + 6)) += l_quantity[i];
            *((float *) (val + 10)) += l_extendedprice[i];
            *((float *) (val + 14)) += getPrice(l_extendedprice[i], l_discount[i]);
            *((float *) (val + 18)) += getTax(l_extendedprice[i], l_discount[i], l_tax[i]);
            *((float *) (val + 22)) += l_discount[i];
        }
    gettimeofday(&stop, NULL);
    test(vals);
    printTime("tpch_q1", start, stop);

    delete[] l_returnflag;
    delete[] l_linestatus;
    delete[] l_quantity;
    delete[] l_extendedprice;
    delete[] l_discount;
    delete[] l_tax;
    delete[] l_shipdate;
    delete vals;

    return 0;
}

int main(int argc, char *argv[]) {
    struct timeval start, stop;
    string file = argv[1];

    float *d = new float[DATA * ATTR];
    float *l = new float[DATA];
    float *w = new float[ATTR];
    float *g = new float[ATTR];
    init(file, d, w, g, l);
    float s[TILE];
    float dots[TILE];

    test(g);
    gettimeofday(&start, NULL);
    for (int i = 0; i < DATA; i += TILE) {
        for (int j = 0; j < TILE; j++) {
            int dOff = (i + j) * ATTR;
            dots[j] = 0.0f;
            for (int k = 0; k < ATTR; k++)
                dots[j] += d[dOff + k] * w[k];
        }
        for (int j = 0; j < TILE; j++) {
            int label = l[i + j];
            s[j] = (1.0f / (1.0f + exp(-label * dots[j])) - 1.0f) * label;
        }
        for (int j = 0; j < TILE; j++) {
            for (int k = 0; k < ATTR; k++) {
                g[k] += s[j] * d[(i + j) * ATTR + k];
            }
        }
    }
    gettimeofday(&stop, NULL);
    test(g);
    printTime("logreg", start, stop);

    delete[] d;
    delete[] l;
    delete[] w;
    delete[] g;

    return 0;
}

int main(int argc, char** argv) {
	Matrix *m1 = NULL, *m2 = NULL, *resultSequential = NULL, *resultParallel = NULL;
	int numParallelTasks = 1;
	struct timeval diff;

	checkArgsSize(argc);
	
	m1 = readMatrixFromFile(M1);
	m2 = readMatrixFromFile(M2);
	 
	checkInputMatrices(m1, m2);
	checkNumTasks(argv, &numParallelTasks, m1);
		
	diff = measureBalanceWork(m1, m2, numParallelTasks, &resultParallel, balanceWork);
	writeMatrixInFile(OUT, resultParallel);
		 	
	printTime("Tempo levado para executar a multiplicação com %d threads: ", numParallelTasks, diff);

	pthread_exit(NULL);
}

void main( void )
{
// Stop watchdog timer to prevent time out reset
  WDTCTL = WDTPW + WDTHOLD;
  initDisplay();
  clearDisplay();
  printString("Hello Masters");

  while(1) 
  {
  {    
  // insert code here to periodically update the display and update global
  // variables that count seconds, minutes and hours.
  // Suggestion: update the display each time the number of seconds changes.
  // You will need to 'calibrate' the delay loop.
    for (k=0; k<60; k++)
{
	for (j=0;j<60;j++)
	{
		for (i=0;i<60;i++)
		{
			clearDisplay();
                        delay(65535);
			seconds = i;
			
		}
		minutes=j;
	}
	hours=k;
}

  
    
    delay(65535); //this controls rate of counter, 65535 is maximum value of 16bit counter
    counter++;
    printTime(hours, minutes, seconds);
    clearDisplay();
    printDecimal(counter);
  }
  }
}

   std::string FileSpec::toString(const gpstk::CommonTime& dt,
                                  const FSTStringMap& fstsMap) const
   {
      string toReturn;

         // Go through the list and insert all the non-date elements
         // into the string.  In other words, fill in the string with data
         // from the FSTSMap first.. For date elements, put the FileSpec string
         // directly into the file name (i.e. '%3j').  Then use CommonTime::printf
         // to fill in all the date elements at the end.
      vector<FileSpecElement>::const_iterator fslItr = fileSpecList.begin();
      while (fslItr != fileSpecList.end())
      {
         FSTStringMap::const_iterator fstsItr = fstsMap.find((*fslItr).type);
            // once again, it its found in the map, replace that part of
            // the file spec. otherwise, just put the fixed field in.
         if (fstsItr != fstsMap.end())
         {
               // special case for 'text': just print it
            if ((*fstsItr).first == text)
            {
               toReturn += (*fstsItr).second;
            }
            else
            {
               toReturn += 
                  rightJustify((*fstsItr).second, (*fslItr).numCh, '0');
            }
         }
         else
         {
            toReturn += (*fslItr).field;
         }

         fslItr++;
      }

      toReturn = printTime(dt,toReturn);

      return toReturn;
   }

int main(int argc, char *argv[]) {
    int *data1 = new int[DATA];
    int *data2 = new int[DATA];
    initData(data1, DATA);
    initData(data2, DATA);

    struct timeval start, stop;
    gettimeofday(&start, NULL);
    vector<int *> res1;
    vector<int *> res2;
    res1.push_back(new int[DATA]);
    res2.push_back(new int[DATA]);
    int pos = 0;
    int *tile1 = data1;
    int *tile2 = data2;
    int bitmap[TILE];
    for (int i = 0; i < TILES; i++) {
        for (int j = 0; j < TILE; j++)
            bitmap[j] = (tile1[j] < PVAR)
                      & (tile2[j] < PMAX);
        for (int j = 0; j < TILE; j++)
            if (bitmap[j]) {
                res1.back()[pos] = tile1[j];
                res2.back()[pos++] = tile2[j];
            }
        tile1 += TILE;
        tile2 += TILE;
    }
    gettimeofday(&stop, NULL);

    printAlgo(__FILE__, PVAR, res1.size());
    printTime(start, stop);

    delete[] data1;
    delete[] data2;
    for (int i = 0; i < res1.size(); i++) {
        delete[] res1[i];
        delete[] res2[i];
    }
    return 0;
}

int main(void) {
  int snake[300][2],
      len_snake=10,
      pommes[20][2],
      len_pommes=5,
      i;
  unsigned long int temps = Microsecondes();
  initSnake(snake);
  initPommes(pommes);
  
  srand(time(NULL));
  InitialiserGraphique();
  CreerFenetre(BORD,BORD,600+2*BORD,400+BORD+40);

  printTerrain(snake, len_snake, pommes, len_pommes);
  printTime(temps);
    
  Touche();
  FermerGraphique();
  return EXIT_SUCCESS;
}

void MatrixGenerator::parallelOpenMP_CRS(CRS* crs) {
  cout << "Computing CRS... " << flush;
  initializeTime();

  int ckey = 0, 
	  j = 0,
	  chunk = 1000;

  #pragma omp for private(ckey,j) schedule(static,chunk)
  //#pragma omp parallel for
  for (int i=0 ; i<m ; i++){
    for (ckey=crs->rowPtr[i] ; ckey<crs->rowPtr[i+1] ; ckey++) {
		j = crs->colId[ckey];
      resultVector[i] += crs->val[ckey] * multiVector[j];
    }
  }

  cout << "done parallel OpenMP" << endl;
  cout << "->Time elapsed [CRS]: " << endl; //setprecision(6) << elapsedTime << endl;
  printTime();
}

void 
ClockerListener::printTest( int testIndex,
                            const std::string &indentString ) const
{
  std::string indent = indentString;
  const int indentLength = 3;

  printTestIndent( indentString, indentLength );
  printTime( m_model->testTimeFor( testIndex ) );

  CPPUNIT_NS::stdCOut()  <<  m_model->testPathFor( testIndex ).getChildTest()->getName();
  CPPUNIT_NS::stdCOut()  <<  "\n";

  if ( m_model->childCountFor( testIndex ) == 0 )
    indent+= std::string( indentLength, ' ' );
  else
    indent+= "|" + std::string( indentLength -1, ' ' );

  for ( int index =0; index < m_model->childCountFor( testIndex ); ++index )
    printTest( m_model->childAtFor( testIndex, index ), indent );
}

int main(int argc, char *argv[])
{
	initializeDatabase();

	wiringPiSetup();

	printTime();
	printf(LANG_PROGRAM_TITLE);

	while (1) {
		int level = digitalRead(RECIEVE_PIN);

		int bitLength = findEncodedBitLength(level);
		decodeBitLength(bitLength);

		delayMicroseconds(50);

		globalLevelsCounter++;
	}
	return 0;
}

void MatrixGenerator::parallelPthreads_CRS(CRS* crs) {
  cout << "Computing CRS... " << flush;

  pthread_t * threads = new pthread_t[numThreads];
  
  PthreadData * data = new PthreadData();
  data->crs = crs;
  data->resultVector = resultVector;
  data->multiVector = multiVector;
  data->m = m;

  initializeTime();
  for (int i=0 ; i<numThreads ; i++) {
	  data->threadID = i;
	  pthread_create( &threads[i], NULL, algorithmForThread, &data);
  }

  cout << "done parallel Pthreads" << endl;
  cout << "->Time elapsed [CRS]: " << endl; //setprecision(6) << elapsedTime << endl;
  printTime();
}

void event_clocktick_handle(event_t* event,
			    struct TOS_state* state) {

  event_queue_t* queue = &(state->queue);
  clock_tick_data_t* data = (clock_tick_data_t*)event->data;

  // Viptos: _PTII_NODEID is passed to the preprocessor as a macro definition.
  // Viptos: We assume that there is only one node per TOSSIM.
  //atomic TOS_LOCAL_ADDRESS = (short)(event->mote & 0xffff);
  atomic TOS_LOCAL_ADDRESS = (short)(_PTII_NODEID & 0xffff);

  /*
  if (TOS_LOCAL_ADDRESS != event->mote) {
    dbg(DBG_ERROR, "ERROR in clock tick event handler! Things are probably ver bad....\n");
  }
  */
    
  if (data->valid) {
    if (dbg_active(DBG_CLOCK)) {
      char buf[1024];
      printTime(buf, 1024);
      dbg(DBG_CLOCK, "CLOCK: event handled for mote %i at %s (%i ticks).\n", event->mote, buf, data->interval);
    }

    setTime[NODE_NUM] = tos_state.tos_time;
    event->time = event->time + data->interval;
    queue_insert_event(queue, event);
    if (!data->disabled) {
      TOS_ISSUE_INTERRUPT(SIG_OUTPUT_COMPARE2)();
    }
    else {
      interruptPending[NODE_NUM] = 1;
    }
  }
  else {
    //dbg(DBG_CLOCK, "CLOCK: invalid event discarded.\n");
    
    event_cleanup(event);
  }
}

void Logger::pop(bool success)
{ 
    if (!parents_.empty())
    {
        Timer timer = timers_.top();
        const string parent = parents_.top();
        const bool interrupt = interrupts_.top();

        timers_.pop();
        parents_.pop();
        interrupts_.pop();

        if (active_)
        {
            if (maxLevel_ < 0 || getCurrentLevel() < maxLevel_)
            {
                if (interrupt) 
                {
                    indent();

                    if (parents_.size() > 0) {
                        cout << " `- ";
                    }

                    cout << parent << " ... ";
                    
                }

                if (success) {
                    cout << getConfirmation() << " ";
                } else {
                    cout << "FAILURE ";
                    exit(EXIT_FAILURE);
                }

                printTime(timer);
            }
        }
    }
}

int main(int argc, char *argv[]) {
    struct timeval start, stop;
    string file1 = argv[1];
    string file2 = argv[2];

    int *o_orderkey = new int[Q4_ORDERS];
    long *o_orderdate = new long[Q4_ORDERS];
    char *o_orderpriority = new char[Q4_ORDERS];
    int *l_orderkey = new int[Q4_LINEITEM];
    long *l_commitdate = new long[Q4_LINEITEM];
    long *l_receiptdate = new long[Q4_LINEITEM];
    init(file1, file2, o_orderkey, o_orderdate, o_orderpriority, l_orderkey,
            l_commitdate, l_receiptdate);
    unordered_set<int> *exists = new unordered_set<int>();
    unordered_map<char,int> *vals = new unordered_map<char,int>();

    test(vals);
    gettimeofday(&start, NULL);
    for (int i = 0; i < Q4_LINEITEM; i++)
        if (l_commitdate[i] < l_receiptdate[i])
            exists->insert(l_orderkey[i]);
    for (int i = 0; i < Q4_ORDERS; i++)
        if (o_orderdate[i] >= Q4_DATE1 && o_orderdate[i] < Q4_DATE2)
            if (exists->find(o_orderkey[i]) != exists->end())
                (*vals)[o_orderpriority[i]]++;
    gettimeofday(&stop, NULL);
    test(vals);
    printTime("tpch_q4", start, stop);

    delete[] o_orderkey;
    delete[] o_orderdate;
    delete[] o_orderpriority;
    delete[] l_orderkey;
    delete[] l_commitdate;
    delete[] l_receiptdate;
    delete exists;
    delete vals;

    return 0;
}

void *binomialOption(void *n)
{
	gmactime_t s, t;
	ecl_error ret = eclSuccess;
	int offset = *(int *)n * numSamples;
	/*cl_float* output_thread = NULL;
	assert(eclMalloc((void **)&output_thread, numSamples * sizeof(cl_float4)) == eclSuccess);*/

	getTime(&s);
	ecl_kernel kernel;
	ret = eclGetKernel("binomial_options", &kernel);
	assert(ret == eclSuccess);	
	ret = eclSetKernelArg(kernel, 0, sizeof(numSteps), &numSteps);
	assert(ret == eclSuccess);	
	ret = eclSetKernelArgPtr(kernel, 1, randArray);
	assert(ret == eclSuccess);	
	ret = eclSetKernelArgPtr(kernel, 2, output);
	assert(ret == eclSuccess);	
	//assert(eclSetKernelArgPtr(kernel, 2, output_thread) == eclSuccess);
	ret = eclSetKernelArg(kernel, 3, (numSteps + 1) * sizeof(cl_float4), NULL);
	assert(ret == eclSuccess);	
	ret = eclSetKernelArg(kernel, 4, numSteps * sizeof(cl_float4), NULL);
	assert(ret == eclSuccess);	
	ret = eclSetKernelArg(kernel, 5, sizeof(offset), &offset);
	assert(ret == eclSuccess);

	size_t globalThreads[] = {numSamples * (numSteps + 1)};
	size_t localThreads[] = {numSteps + 1};
	ret = eclCallNDRange(kernel, 1, NULL, globalThreads, localThreads);
	assert(ret == eclSuccess);	
	getTime(&t);
	printTime(&s, &t, "Run: ", "\n");
	//eclMemcpy(&output[offset], output_thread, numSamples * sizeof(cl_float4));

	ret = eclReleaseKernel(kernel);
	assert(ret == eclSuccess);
	//assert(eclFree(output_thread) == eclSuccess);

	return NULL;
}

int main(int argc, char *argv[]) {
    int *data1 = new int[DATA];
    initData(data1, DATA);

    struct timeval start, stop;
    gettimeofday(&start, NULL);
    vector<int *> res1;
    res1.push_back(new int[DATA]);
    int pos = 0;
    for (int i = 0; i < DATA; i++)
        if (data1[i] < PVAR)
            res1.back()[pos++] = data1[i];
    gettimeofday(&stop, NULL);

    printAlgo(__FILE__, PVAR, res1.size());
    printTime(start, stop);

    delete[] data1;
    for (int i = 0; i < res1.size(); i++)
        delete[] res1[i];
    return 0;
}

/** outputs a new global upper bound to the visualization output file */
void SCIPvisualUpperbound(
   SCIP_VISUAL*          visual,             /**< visualization information */
   SCIP_SET*             set,                /**< global SCIP settings */
   SCIP_STAT*            stat,               /**< problem statistics */
   SCIP_Real             upperbound          /**< new upper bound */
   )
{
   assert( visual != NULL );

   /* check, if VBC output should be created */
   if( visual->vbcfile == NULL )
      return;

   /* determine external upper bound */
   if ( set->visual_objextern )
      upperbound = SCIPretransformObj(set->scip, upperbound);

   printTime(visual, stat, TRUE);
   SCIPmessageFPrintInfo(visual->messagehdlr, visual->vbcfile, "U %f\n", upperbound);

   /* do nothing for BAK */
}

int main(int argc, char *argv[]) {
    struct timeval start, stop;
    string file = argv[1];

    float *l_quantity = new float[Q6_LINEITEM];
    float *l_extendedprice = new float[Q6_LINEITEM];
    float *l_discount = new float[Q6_LINEITEM];
    long *l_shipdate = new long[Q6_LINEITEM];
    init(file, l_quantity, l_extendedprice, l_discount, l_shipdate);
    float revenue = 0.0f;
    int bitmap[TILE];

    test(revenue);
    gettimeofday(&start, NULL);
    for (int i = 0; i < Q6_LINEITEM; i += TILE) {
        for (int j = 0; j < TILE; j++)
            bitmap[j] = l_shipdate[i + j] >= Q6_DATE1
                      * l_shipdate[i + j] < Q6_DATE2;
        for (int j = 0; j < TILE; j++)
            bitmap[j] *= l_discount[i + j] >= 0.05f
                       * l_discount[i + j] <= 0.07f;
        for (int j = 0; j < TILE; j++)
            bitmap[j] *= l_quantity[i + j] < 24.0f;
        for (int j = 0; j < TILE; j++)
            if (bitmap[j])
                revenue += l_extendedprice[i + j] * l_discount[i + j];
    }
    gettimeofday(&stop, NULL);
    test(revenue);
    printTime("tpch_q6_mk7", start, stop);

    delete[] l_quantity;
    delete[] l_extendedprice;
    delete[] l_discount;
    delete[] l_shipdate;

    return 0;
}

void drawChooseMood(void){
	
	currentMenuLength = moodArrSize;
	uint8_t index = 0;
	uint8_t menuPage = 0;
	uint8_t totalPages = 0;
	
	char moodString[18];
	
	
	printTime();
	printStringOnLine(1,"   Choose Mood    ", 1,NONE);
	
	for (uint8_t i = 0; i < cellsPerFrame; i++){
		memset(moodString,0,sizeof(moodString));
		totalPages = ((currentMenuLength-1)/cellsPerFrame);
		menuPage = (selectionInMenu/cellsPerFrame);	
		index = ((menuPage)*cellsPerFrame)+i;
		
		if(index < currentMenuLength){
			snprintf(moodString, sizeof(moodString), "%s%s%s", " ", moodArray[index], "                  ");
			moodString[17] = ' ';
		}

		drawMenuBands(menuPage,totalPages,TOPBAND);			
				
		//Draw Menu Contents
		if (i == selectionInFrame)
			printStringOnLine(i+yOffset,moodString, 1,NOBOXMENU);
		else if (index < currentMenuLength)
			printStringOnLine(i+yOffset,moodString, 0,NOBOXMENU);
		else
			printStringOnLine(i+yOffset,"                  ", 0,NOBOXMENU);
			
		drawMenuBands(menuPage,totalPages,BOTTOMBAND);	
			
	}				
}

void decodePluviometer()
{
	if (encodedBits[9] && encodedBits[10] && !encodedBits[11]
	    && encodedBits[12] && encodedBits[13] && !encodedBits[14]
	    && !encodedBits[15]) {
		unsigned int rain = 0;
		int i;
		for (i = 16; i < 32; i++) {
			rain |= encodedBits[i] << (i - 16);
		}

		printTime();
		float rainFinal = (float)rain / 4;
		printf(LANG_INFO_PLUVIOMETER, (float)rainFinal);
		savePluviometer(rainFinal);

		if (encodedBits[8]) {
			printf(LANG_BATTERY_REPLACE);
		} else {
			printf(LANG_BATTERY_OK);
		}
	}
}