int main() {
	int a,b,x;
	generate(&a);
	b=5;
	x=printValue(sum(&a,&b));
	return printValue(x);
}

//
// Print out a points-to set.
//
static void printPointsToSet(raw_ostream &Stream, const PointsToSet &Set) {
  PointsToSet::iterator PTIt = Set.begin(), PTItEnd = Set.end();
  Stream << "printing points to set...\n";
  for (; PTIt != PTItEnd; ++PTIt) {
    PointsToNode *Node = PTIt->first;
    const Field &F = PTIt->second;

    Stream << "  - ";

    switch (Node->Kind) {
      case PointsToNode::TYPE_SAFE:
        Stream << "(";
        printValue(Stream, Node->getAllocationSite());
        Stream << ", ";
        F.print(Stream);
        Stream << ")";
        break;
      case PointsToNode::TYPE_UNSAFE:
        Stream << "(";
        printValue(Stream, Node->getAllocationSite());
        Stream << ", collapsed)";
      case PointsToNode::EXTERNAL:
        Stream << "(";
        if (Node->getAllocationSite() == 0)
          Stream << "external";
        else
          printValue(Stream, Node->getAllocationSite());
        Stream << ", collapsed)";
        break;
    }

    Stream << "\n";
  }
}

void
ArxDbgEdInputContextReactor::printPointIn(const AcGePoint3d* pointIn) const
{
	CString str;
	if (pointIn != NULL)
		printValue(_T("POINT IN"), ArxDbgUtils::ptToStr(*pointIn, str));
	else
		printValue(_T("POINT IN"), _T("Null"));
}

int main() {
  Foo my_foo(4.2);
  double my_double(1.0);

  printValue(my_foo);
  printValue(my_double);

  return 0;
}

void SensorWidget::paintSystemSensorData()
{
  const SystemSensorData& data = sensorView.systemSensorData;
  print("System sensor data:", "");
  print(" Cpu temperatur", printValue(ValueType::temperatur, data.cpuTemperature));
  print(" Battery current", printValue(ValueType::current, data.batteryCurrent));
  print(" Battery level", printValue(ValueType::ratio, data.batteryLevel));
  print(" Battery temperatur", printValue(ValueType::ratio, data.batteryTemperature));
}

int main() {
  Foo my_foo(4.2);
  double my_double(1.0);

  printValue(my_foo);
  printValue(my_double);  // Error: no implicit conversion

  return 0;
}

void
ArxDbgEdInputContextReactor::endDragSequence(Acad::PromptStatus returnStatus,
                    AcGePoint3d& pickPoint, AcGeVector3d& vec)
{
	printReactorMessage(_T("End Drag Sequence"));

	if (m_showDetails) {
		CString str;
		printReturnStatus(returnStatus);
		printValue(_T("PICK POINT"), ArxDbgUtils::ptToStr(pickPoint, str));
		printValue(_T("VECTOR"), ArxDbgUtils::vectorToStr(vec, str));
	}
}

//
// Print out a summary of the points-to sets of the graph.
//
void PointsToGraph::printGraph(raw_ostream &Stream) {
  const char *Break = "------------------------------\n";

  Stream << "SCALAR MAP\n";

  //
  // Write out the scalar map.
  //
  ScalarMapTy::iterator SMIt = ScalarMap.begin(), SMItEnd = ScalarMap.end();
  for (; SMIt != SMItEnd; ++SMIt) {
    const Value *Pointer = SMIt->first;
    const PointsToSet &PTS = SMIt->second;

    Stream << Break;
    Stream << "Pointer: ";
    printValue(Stream, Pointer);
    Stream << "\n";
    Stream << "Points-to set:\n";
    printPointsToSet(Stream, PTS);
  }

  Stream << "POINTS-TO GRAPH\n";

  //
  // Write out the nodes in the points-to graph.
  //
  NodeMapTy::iterator NMIt = GraphNodes.begin(), NMItEnd = GraphNodes.end();
  for (; NMIt != NMItEnd; ++NMIt) {
    PointsToNode *Node = NMIt->second;
    Value *AllocSite = Node->getAllocationSite();

    Stream << Break;

    Stream << "Allocation site: ";
    printValue(Stream, AllocSite);
    Stream << "\n";

    EdgeMap &Edges = Node->getEdges();
    EdgeMap::iterator EIt = Edges.begin(), EItEnd = Edges.end();
    for (; EIt != EItEnd; ++EIt) {
      const Field &F = EIt->first;
      const PointsToSet &PTS = EIt->second;

      Stream << " At field ";
      F.print(Stream);
      Stream << ":\n";

      printPointsToSet(Stream, PTS);
    }
  }
}

void PhantomJSHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser)
{
  CEF_REQUIRE_UI_THREAD();

  qCDebug(handler) << browser->GetIdentifier();

  auto& browserInfo = m_browsers[browser->GetIdentifier()];
  browserInfo.browser = browser;
  if (!m_popupToParentMapping.isEmpty()) {
    auto parentBrowser = m_popupToParentMapping.dequeue();
    // we don't open about:blank for popups
    browserInfo.firstLoadFinished = true;
    emitSignal(m_browsers.value(parentBrowser).browser, QStringLiteral("onPopupCreated"),
               {browser->GetIdentifier()}, true);
  }

#if CHROME_VERSION_BUILD >= 2526
  if (PRINT_SETTINGS) {
    auto prefs = browser->GetHost()->GetRequestContext()->GetAllPreferences(true);
    CefDictionaryValue::KeyList keys;
    prefs->GetKeys(keys);
    for (const auto& key : keys) {
      printValue(key, prefs->GetValue(key));
    }
  }
#endif
}

wxCustomSpinCtrl::wxCustomSpinCtrl( wxWindow*         parent,
                                    wxWindowID        id,
                                    float             min,
                                    float             max,
                                    float             initial,
                                    float             increment,
                                    int               digits )
    :
    wxPanel    ( parent    ),
    m_Parent   ( parent    ),
    m_ID       ( id        ),
    m_Value    ( initial   ),
    m_MaxValue ( max       ),
    m_MinValue ( min       ),
    m_Increment( increment ),
    m_Digits   ( digits    )
{
    m_TextControl = new wxTextCtrl( this, wxID_ANY, _(""), wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER );

    m_SpinButton  = new wxSpinButton( this, wxID_ANY );
    m_SpinButton->SetRange( -100000, +100000 );
    m_SpinButton->SetValue( 0 );

    wxBoxSizer*  topSizer = new wxBoxSizer( wxHORIZONTAL );
    topSizer->Add( m_TextControl, 0, wxALIGN_CENTER|wxALIGN_CENTER_VERTICAL );
    topSizer->Add( m_SpinButton,  0, wxALIGN_CENTER|wxALIGN_CENTER_VERTICAL );

    SetSizerAndFit( topSizer );

    printValue( m_Value );
}

static int
printAttribute(D4printer* out, NCD4node* attr, int depth)
{
    int ret = NC_NOERR;
    int i = 0;
    char* fqn = NULL;

    INDENT(depth); CAT("<Attribute");
    printXMLAttributeName(out,"name",attr->name);
    if(attr->basetype->subsort <=  NC_MAX_ATOMIC_TYPE)
	printXMLAttributeName(out,"type",attr->basetype->name);
    else {
	printXMLAttributeName(out,"type",(fqn = NCD4_makeFQN(attr->basetype)));
    }
    CAT(">\n");
    depth++;
    for(i=0;i<nclistlength(attr->attr.values);i++) {
	printValue(out,(const char*)nclistget(attr->attr.values,i),depth);
	CAT("\n");
    }
    depth--;
    INDENT(depth);
    CAT("</Attribute>");

    nullfree(fqn);
    return THROW(ret);
}

/* prints the elements in the same value */
void recursivePrintValue(FILE *f, NodeT *node, int level)
{
    if (level < node->level)
    {
        return;
    }
    if (level == node->level)
    {
        printValue(f, node);
        fprintf(f, " ");
        if (node == printNull)
        {
            return;
        }
    }
    if (node->left->value == -1)
    {
        node->left->level = node->level+1;
    }
    recursivePrintValue(f, node->left, level);
    if (node->value == -1)
    {
        node->level--;
    }
    if (node->right->value == -1)
    {
        node->right->level = node->level+1;
    }
    recursivePrintValue(f, node->right, level);
}

void PrintStatement::evaluate(SymTab &symTab, std::unique_ptr<FuncTab> &funcTab) {
	for (auto &l: _rhsList ) {
        printValue( l->evaluate(symTab, funcTab).get() );
		std::cout << ' ';
	}
	std::cout << std::endl;
}

SpinBoxDecimale::SpinBoxDecimale(int value, QWidget *parent): QAbstractSpinBox(parent)
{
    setReadOnly(true);
    setAlignment(Qt::AlignRight);
    setValue(value);
    printValue();
}

void setRegistryValue(bool registryNum[8], bool value[8]) {
	try{
	bool* output = new bool[8];
	bool tmpCheck = 0;
	bool* low = new bool[8];
	bool* high = new bool[8];
	if ( Eightto1bit(tmpCheck, lessthan(output, registryNum, low))) throw 10;
	if ( Eightto1bit(tmpCheck, greaterthan(output, registryNum, high))) throw 10;
	value[0] = registry[to_int8(registryNum)][0];
	value[1] = registry[to_int8(registryNum)][1];
	value[2] = registry[to_int8(registryNum)][2];
	value[3] = registry[to_int8(registryNum)][3];
	value[4] = registry[to_int8(registryNum)][4];
	value[5] = registry[to_int8(registryNum)][5];
	value[6] = registry[to_int8(registryNum)][6];
	value[7] = registry[to_int8(registryNum)][7];
	}
	catch (int e) {
		std::cout<<"Reg(";
		printValueInDecimal(registryNum);
		std::cout<<") = ";
		printValue(registryNum);
		std::cout<<'\n';
	}
}

// Prints the tree to the screen in a readable fashion. It should look just like
// Racket code; use parentheses to indicate subtrees.
void printTree(Value *tree){
    if (tree->type == NULL_TYPE) {
        return;
    }
    //if the current head of tree is a cons type, then go to its car
    else if (tree->type == CONS_TYPE) {
        //if the car is a cons type as well, enclose it in parentheses and recurse 
        if (car(tree)->type == CONS_TYPE) {
            printf("(");
            printTree(car(tree));
            printf(")");
            //adds a space after the end of a subtree (for formatting reasons)
            if (cdr(tree)->type != NULL_TYPE){
                printf(" ");
            }
            //recurse on the rest of the tree
            printTree(cdr(tree));
        }
        //if the car is not a cons type, print the car and recurse on the rest of the tree
        else{
            printTree(car(tree));
            if (cdr(tree)->type != NULL_TYPE){
                printf(" ");
            }
            printTree(cdr(tree));
        }
    } 
    //if the current head is not a cons type, print it
    else {
        printValue(tree);
        return;
    }
}

void printTypeAndValue(llvm::raw_ostream &out, EValuePtr ev)
{
    printName(out, ev->type.ptr());
    out << "(";
    printValue(out, ev);
    out << ")";
}

SEXP getTable(const std::shared_ptr<cpptoml::table>& t, bool verbose=false) {
    Rcpp::StretchyList sl;
    for (auto & p : *t) {
        if (p.second->is_table()) {
            auto ga = std::dynamic_pointer_cast<cpptoml::table>(p.second);
            if (verbose) Rcpp::Rcout << "Table: " << p.first << std::endl;
            sl.push_front(Rcpp::Named(p.first) = getTable(ga, verbose));
        } else if (p.second->is_array()) {
            auto ga = std::dynamic_pointer_cast<cpptoml::array>(p.second);
            if (verbose) {
                Rcpp::Rcout << "Array: " << p.first << std::endl;
                printArray(Rcpp::Rcout, *ga);
            }
            sl.push_front(Rcpp::Named(p.first) = getArray(*ga)); 
        } else if (p.second->is_value()) {
            if (verbose) {
                Rcpp::Rcout << "Value: " << p.first << "\n  :";
                printValue(Rcpp::Rcout, p.second);
                Rcpp::Rcout << std::endl;
            }
            sl.push_front(Rcpp::Named(p.first) = getValue(p.second)); 
            
        } else {
            Rcpp::Rcout << "Other: " << p.first << std::endl;
            sl.push_front(p.first); 
        }
    }
    return Rcpp::as<Rcpp::List>(sl);
}

// Render an array to text
int
aJsonClass::printArray(aJsonObject *item, FILE* stream)
{
  if (item == NULL)
    {
      //nothing to do
      return 0;
    }
  aJsonObject *child = item->child;
  if (fputc('[', stream) == EOF)
    {
      return EOF;
    }
  while (child)
    {
      if (printValue(child, stream) == EOF)
        {
          return EOF;
        }
      child = child->next;
      if (child)
        {
          if (fputc(',', stream) == EOF)
            {
              return EOF;
            }
        }
    }
  if (fputc(']', stream) == EOF)
    {
      return EOF;
    }
  return 0;
}

void createRandomTile(struct tile ** board, int size, int pos_rel, int multi) {
    time_t t;
    srand((unsigned) time(&t));
    //randomize the col and row position
    int row = rand() % size;
    int col = rand() % size;
    int value = board[row][col].value;
    //check if the board is filled up
    bool filled = fillUpTile(board, size);

    //that position is blank
    if (value == 0) {
        board[row][col].value = random_2_4();
        printTile(board[row][col], row, col, pos_rel);
        printValue(board, size, pos_rel);
    } else {
        //the random tile is not empty and the board has not been filled up
        while (value != 0 && filled == false) {
            row = rand() % size;
            col = rand() % size;
            //the random tile is not empty
            if (board[row][col].value != 0) {
                value = board[row][col].value;
                filled = fillUpTile(board, size);
            } else {
                //random between value 2 and 4
                board[row][col].value = random_2_4();
                printTile(board[row][col], row, col, pos_rel);
                printValue(board, size, pos_rel);
                filled = fillUpTile(board, size);
                break;
            }
        }
    }
    //check the board has possible moves
    bool move = canMove(board, size);

    //the board is filled up and there is no move left for 1 player only
    if (multi == 0) {
        if (filled == true && move == false) {
            //delete win
            mvprintw(25, 2, "                            ");
            //print game over
            mvprintw(15, 2, "Game over!!");
        }
    }
}