Как создать запускающий файл?

// 2.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "2.h"
int static TMove; gMove; //сюда вернется лучший ход 
int Search(int alpha,int beta,int Depth, int ply); 
{
//пока не нашли лучшего хода
NoFindMove(retMove); 
if (Depth <= 0 | I TimeOverO()) return Evaluate (); 
TMove tmpMove; //стековая промежуточная переменная
//найдем лучший ход на меньшую глубину
Search(alpha,beta,Depth-2,retMove,ply); 
//если лучший ход найдем, попробуем его первым
if(findMove) 
}
{ 
MakeMove(retMove); 
int tmp = -Search(-beta,-alpha,Depth-1, 
&tmpMove, //нам не потребуется
ply+1); 
UnMakeMove(retMove); 
if(tmp > alpha) alpha = tmp; 
if(alpha >= beta) return alpha; 
} 
//основной счет 
{...} 
///допустим, нашли ход
{...} 
{
MakeMove (move) ; 
tmp = -Search(-beta,-alpha,Depth-1,&tmpMove,ply+1); 
UnMakeMove(move); 
if(tmp > alpha) 
{ 
alpha = tmp; 
if(!TimeOver() ) 
memcpy(retMove,move,sizeof(TMove)); 
} 
if(alpha >= beta) return alpha; 
{...} 
return alpha; 
} 
{
typedef struct _TMove{ 
int xl,yl,x2,y2; //откуда и куда пошла фигура
int f; //сама фигура 
int newF; //значение фигуры на новом месте
//пешка после превращения меняет значение
int eatFX, eatFY;//координаты съеденной фигуры
//при взятии пешкой через битое поле
//эти координаты не совпадают с новым
//местом фигуры
int eatF; //сама съеденная фигура
int score; //приращение оценки при ходе
bool isExtMoveKing; //рокировка? 
int Depth; //глубина счета
}TMove,*PMove; 
#define B BLACK 
#define W WHITE 
static unsigned char _pos [ 8 ] [ 8 ] = 
{ROOK|Р’,KNIGHT|Р’,BISHOP|Р’ }, 
{...}
}
//делает перемещение
(void MakeMove(PMove move));
{ 
if(!move->isExtMoveKing) 
{ 
_pos[move->yl][move->xl] = 0; 
_pos[move->eatFY][move->eatFX] = 0; 
_pos[move->y2][move->x2] = move->newF; 
}else{ 
//рокировка
    {...}
}
}
//восстанавливает позицию
(void UnMakeMove(PMove move));
{ 
//все в обратном порядке
    {...}
}
{
    //массивы со стратегической оценкой
typedef int TStBoard[8][8]; 
//стратегическая оценка 
//для верхних
static TStBoard _upSt = 
{ 
{ 1, 2, 3, 4, 5, 6, 7, 8}, 
{ 9,10,11,12,13,14,15,16}, 
{17,18,19,20,21,22,23,24}, 
{25,26,27,28,29,30,31,32}, 
{33,34,35,36,37,38,39,40}, 
{41,42,43,44,45,46,47,48}, 
{49,50,51,52,53,54,55,56}, 
{57,58,59,60,61,62,63,64} 
}; 
//для нижних
static TStBoard _botSt = 
{ 
{64,63,62,61,60,59,58,57}, 
{56,55,54,53,52,51,50,49}, 
{48,47,46,45,44,43,42,41}, 
{40,39,38,37,36,35,34,33}, 
{32,31,30,29,28,27,26,25}, 
{24,23,22,21,20,19,18,17}, 
{16,15,14,13,12,11,10, 9}, 
{ 8, 7, 6, 5, 4, 3, 2, 1} 
};
//массив быстрой перекодировки кода фигуры в ее вес
static int _wf [7] = {0,W_KING,W_QUEEN,W_ROOK,W_BISHOP,W_KNIGHT,W_PAWN} ; 
//возвращает приращение оценки хода
int delRes( TStBoard *myB, //оценка наших фигур
TStBoard *opB, //противника
PMove move //описатель перемещения
)
{
int score; 
if(move->isExtMoveKing) 
{ 
//рокировка
{...} 
}else{ 
score = _wf[FIGURE(move->newF) - _wf[FIGURE(move->f)] + 
(*myB) [move->y2] [move->x2] - 
(*myB) [move->yl] [move->xl] ; 
if(eatF) 
{ 
score += _wf[FIGURE(move->eatF); 
score += (*opB)[move->eatFY][move->eatFX]; 
}
}
return score; 
} 
//цвет верхних фигур
static int _upFColor; 
//сама функция счета (схематично)
int Search(PMove node, //описатель хода в эту позицию
int Depth, //сколько полуходов осталось
int ply, //абсолютная глубина от 0 
int alpha, 
int beta, 
PMove retMove, //найденный ход
int score, //текущая оценка узла
bool isLazyEval, //идет сокращенный просчет
int color //цвет наших фигур
)
{
TStBoard *myB,*opB; 
int nextColor = color=BLACK?WHITE:BLACK; 
//инициализируем переменные
if(color != _upFColor) 
{ 
//если наши фигуры нижние
myB = &_botSt; opB = &_upSt; 
}else{ 
myB = &_upSt; opB = &_botSt; 
} 
retMove->f = 0; //нет пока лучшего хода
if(Depth <= 0 || TimeOver()) return score; 
int res = -INFINITY; //возвращаемая оценка
//в эту стековую переменную будет возвращен лучший ход
TMove tmpMove; 
//структура выборочного поиска
static int ext[100] = 
{-64,-64,-64,-64, 
-64,W_PAWN,W_BISHOP,W_ROOK,W_QUEEN,INFINITY,INFINITY,...}; 
//повышаем alpha текущей оценкой
if(ply > 0 && //если не первый полуход
node->score < ext[ply] && //ход не продлевается
!lnCheck(node) //не шах
)
{
res = score; 
if(res > alpha) alpha = res; 
if(alpha >= beta) return alpha; 
}
//переберем на глубину Depth-2 для получения
//лучшего хода 
int tmp = Search(node,Depth-2,ply,alpha,beta, 
retMove, 
score, 
ply==O?false:true, 
color 
); 
/// lazy eval ///// 
//если данный узел удовлетворяет некоторым требованиям, 
//мы можем отсечь его, основываясь на результате сокращенного счета
if(retMove->f && //если нашли лучший ход
retMove->Depth >= Depth-2 //достаточная глубина
ply != 0 && //не первый вызов
!isLazyEval && //не делаем сокращенного поиска
score - 64 >= beta && //оценка и поле роста >= beta 
tmp-64 >= beta && //проверка подтверждает
node->score < W_PAWN && //не взятие
!InCheck(node) //не шах
)
{
return beta; //целая ветвь подрезана!!! 
} 
//прежде, чем нашли перемещения,
//попробуем найденный лучший ход
if(retMove->f) //если такой ход найден
{ 
MakeMove(retMove); 
tmp = -Search( retMove, //описатель хода в эту позицию
Depth-1, //сколько полуходов осталось
ply+1, //абсолютная шлубина от 0
-beta, 
-alpha, 
&tmpMove, //найденный ход (нам не нужен)
-(score+retMove->score), //текущая оценка узла
isLazyEval, 
nextColor 
); 
UnMakeMove (retMove) ; 
if(tmp > res) res = tmp; 
if(res > alpha) 
{ 
//если не превышен лимит времени
if(ITimeOver()) 
{ 
//лучший ход тот же,
//только корректируем глубину
retMove->Depth = Depth; 
} 
alpha = res; 
} 
if(alpha >= beta) return alpha; 
}//endif 
///////// взятия ///////////////////////////// 
//нашли взятие - сразу в следующую позицию //// 
{...}
////// допустим, нашли ход //////////////////// 
{...} 
//приращение при ходе
ove->score = delRes(myB,opB,move); 
MakeMove(move); 
tmp = -Search( move, //описатель хода в эту позицию
Depth-1, //сколько полуходов осталось
ply+1, //абсолютная глубина от 0
-beta, 
-alpha, 
&tmpMove, //найденный ход (нам не нужен)
-(score+move->score), //текущая оценка узла
isLazyEval, 
nextColor 
); 
if(tmp > res) res = tmp; 
if(res > alpha) 
{ 
alpha = res; 
if(!TimeOver()) 
{ 
memcpy(retMove,move,sizeof(TMove)); 
retMove->Depth = Depth; 
}
}
if(alpha >= beta) return alpha; 
UnMakeMove(move); 
{...} 
(...) 
return res; 
}
}//end function

#include <iostream>
 
using namespace std;
 
int main()
{
    cout << "Hello, world" << endl;
    system("pause");
}

int Search(int alpha,int beta,int Depth, int ply)
{
/// что то делаем
}