for(int a=0;a<120;a++)
{
        keybd_event(13,0,0,0);//down
        keybd_event(13,0,KEYEVENTF_KEYUP,0);//up
        Sleep(1000);
}

---------------------------DLL
extern "C" __declspec(dllexport) int *PushBack(int *x, int &N, int pb)
{
        N++;
        pb=1;
        int *tmp=new int[N];
        for(int i=0; i
#include 
#include 
using namespace std;
typedef int*(*functionDll)( int *, int&, int );
int main()
{
        HMODULE hLib = LoadLibrary("DLL_Test.dll");
        if(hLib)
        {
        functionDll fpFunction = (functionDll)GetProcAddress(hLib,"PushBack");
                if(fpFunction)
                {
            cout << "Function load." << endl;
        
                        srand ( time(NULL) );
                        int N =rand() % 10 + 1;   //радномим длинны массивов
                        int *y;
                        int *x=new int [N];   //выделяем память для матрицы х
                        for(int i=0; i
            

*****************************************************************
 * File: Mergesort.hh
 * Author: Keith Schwarz ()
 *
 * An implementation of the Mergesort algorithm.  This algorithm
 * is implemented with a focus on readability and clarity rather
 * than speed.  Ideally, this should give you a better sense
 * for how Mergesort works, which you can then use as a starting
 * point for implementing a more optimized version of the algorithm.
 *
 * In case you are not familiar with Mergesort, the idea behind the
 * algorithm is as follows.  Given an input list, we wish to sort
 * the list from lowest to highest.  To do so, we split the list
 * in half, recursively sort each half, and then use a merge algorithm
 * to combine the two lists back together.  As a base case for
 * the recursion, a list with zero or one elements in it is trivially
 * sorted.
 *
 * The only tricky part of this algorithm is the merge step, which
 * takes the two sorted halves of the list and combines them together
 * into a single sorted list.  The idea behind this algorithm is
 * as follows.  Given the two lists, we look at the first element of
 * each, remove the smaller of the two, and place it as the first
 * element of the overall sorted sequence.  We then repeat this
 * process to find the second element, then the third, etc.  For
 * example, given the lists 1 2 5 8 and 3 4 7 9, the merge
 * step would work as follows:
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 * 1 2 5 8      3 4 7 9
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *   2 5 8      3 4 7 9          1
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *     5 8      3 4 7 9          1 2
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *     5 8        4 7 9          1 2 3
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *     5 8          7 9          1 2 3 4
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *       8          7 9          1 2 3 4 5
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *       8            9          1 2 3 4 5 7
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *                    9          1 2 3 4 5 7 8
 *
 * FIRST LIST   SECOND LIST      OUTPUT
 *                               1 2 3 4 5 7 8 9
 *
 * The merge step runs in time O(N), and so using the Master Theorem
 * Mergesort can be shown to run in O(N lg N), which is asymptotically
 * optimal for a comparison sort.
 *
 * Our implementation sorts elements stored in std::vectors, since
 * it abstracts away from the complexity of the memory management for
 * allocating the scratch arrays.
 */
#ifndef Mergesort_Included
#define Mergesort_Included
#include 
#include 
/**
 * Function: Mergesort(vector& elems);
 * Usage: Mergesort(myVector);
 * ---------------------------------------------------
 * Applies the Mergesort algorithm to sort an array in
 * ascending order.
 */
template  
void Mergesort(std::vector& elems);
/**
 * Function: Mergesort(vector& elems, Comparator comp);
 * Usage: Mergesort(myVector, std::greater());
 * ---------------------------------------------------
 * Applies the Mergesort algorithm to sort an array in
 * ascending order according to the specified
 * comparison object.  The comparator comp should take
 * in two objects of type T and return true if the first
 * argument is strictly less than the second.
 */
template 
void Mergesort(std::vector& elems, Comparator comp);
/* * * * * Implementation Below This Point * * * * */
/* We store all of the helper functions in this detail namespace to avoid cluttering
 * the default namespace with implementation details.
 */
namespace detail {
  /* Given vectors 'one' and 'two' sorted in ascending order according to comparator
   * comp, returns the sorted sequence formed by merging the two sequences.
   */
  template 
  std::vector Merge(const std::vector& one, const std::vector& two, Comparator comp) {
    /* We will maintain two indices into the sorted vectors corresponding to 
     * where the next unchosen element of each list is.  Whenever we pick
     * one of the elements from the list, we'll bump its corresponding index
     * up by one.
     */
    size_t onePos = 0, twoPos = 0;
    /* The resulting vector. */
    std::vector result;
    /* For efficiency's sake, reserve space in the result vector to hold all of
     * the elements in the two vectors.  To be truly efficient, we should probably
     * take in as another parameter an existing vector to write to, but doing so
     * would complicate this implementation unnecessarily.
     */
    result.reserve(one.size() + two.size());
    /* The main loop of this algorithm continuously polls the first and second
     * list for the next value, putting the smaller of the two into the output
     * list.  This loop stops once one of the lists is completely exhausted
     * so that we don't try reading off the end of one of the lists.
     */
    while (onePos < one.size() && twoPos < two.size()) {
      /* If the first element of list one is less than the first element of
       * list two, put it into the output sequence.
       */
      if (comp(one[onePos], two[twoPos])) {
        result.push_back(one[onePos]);
        /* Also bump onePos since we just consumed the element at that
         * position.
         */
        ++onePos;
      }
      /* Otherwise, either the two are equal or the second element is smaller
       * than the first.  In either case, put the first element of the second
       * sequence into the result.
       */
      else {
        result.push_back(two[twoPos]);
        ++twoPos;
      }
    }
    /* At this point, one of the sequences has been exhausted.  We should
     * therefore put whatever is left of the other sequence into the
     * output sequence.  We do this by having two loops which consume the
     * rest of both sequences, putting the elements into the result.  Of these
     * two loops, only one will execute, although it isn't immediately
     * obvious from the code itself.
     */
    for (; onePos < one.size(); ++onePos)
      result.push_back(one[onePos]);
    for (; twoPos < two.size(); ++twoPos)
      result.push_back(two[twoPos]);
    /* We now have merged all of the elements together, so we can safely
     * return the resulting sequence.
     */
    return result;
  }
}
/* Implementation of Mergesort itself. */
template 
void Mergesort(std::vector& elems, Comparator comp) {
  /* If the sequence has fewer than two elements, it is trivially in sorted
   * order and we can return without any more processing.
   */
  if (elems.size() < 2)
    return;
  /* Break the list into a left and right sublist. */
  std::vector left, right;
  
  /* The left half are elements [0, elems.size() / 2). */
  for (size_t i = 0; i < elems.size() / 2; ++i)
    left.push_back(elems[i]);
  /* The right half are the elements [elems.size() / 2, elems.size()). */
  for (size_t i = elems.size() / 2; i < elems.size(); ++i)
    right.push_back(elems[i]);
  /* Mergesort each half. */
  Mergesort(left, comp);
  Mergesort(right, comp);
  /* Merge the two halves together. */
  elems = detail::Merge(left, right, comp);
}
/* The Mergesort implementation that does not require a comparator is implemented
 * in terms of the Mergesort that does use a comparator by passing in std::less.
 */
template 
void Mergesort(std::vector& elems) {
  Mergesort(elems, std::less());
}
#endif

class %T% {
public:
    %T%() {
        //Constructor
    }
    virtual ~%T%() {
        //Destructor
    }
 
public:
// Arithmetic operators
    friend const %T% operator+(const %T%&, const %T%&);
    friend const %T% operator-(const %T%&, const %T%&);
    friend const %T% operator*(const %T%&, const %T%&);
    friend const %T% operator/(const %T%&, const %T%&);
 
// Logic operators
    friend const %T% operator==(const %T%&, const %T%&);
    friend const %T% operator!=(const %T%&, const %T%&);
};
 
// Arithmetic operators
    const %T% operator+(const %T% &lval, const %T% &rval) {
        //body
    }
    const %T% operator-(const %T% &lval, const %T% &rval) {
        //body
    }
    const %T% operator*(const %T% &lval, const %T% &rval) {
        //body
    }
    const %T% operator/(const %T% &lval, const %T% &rval) {
        //body
    }
 
// Logic operators
    const %T% operator==(const %T% &lval, const %T% &rval) {
        //body
    }
    const %T% operator!=(const %T% &lval, const %T% &rval) {
        return !(ival == rval);
    }

class %FUNCTOR_NAME% {
public:
    explicit %FUNCTOR_NAME%() {
        //Constructor
    }
    virtual ~%FUNCTOR_NAME%() {
        //Destructor
    }
    void operator()() {
        //Functor body
    }
};

class %APP_NAME% {
public:
    explicit %APP_NAME%() {
        //Constructor
    }
    virtual ~%APP_NAME%() {
        //Destructor
    }
    
    int run() const {
        //Program body  
        return 0;  
    }  
};
 
int main(int argc, char const *argv[], char const *env[]) {  
    int exitCode = 1;
    try {
        exitCode = %APP_NAME%.run();
    }
    catch(...) {
        throw;
    }
    return exitCode;
} 

int GetRndNumber()
{
        typedef boost::mt19937 RNGType;
        boost::random::random_device rd;
        RNGType rng(rd());
        boost::uniform_int<> one_to_one( 1, 10);
        boost::variate_generator< RNGType, boost::uniform_int<> >dice(rng, one_to_one);
        return dice();
}

//----------GET
string GetRequest(string reference)
{
try
{
        string text;
        URI uri(reference);
        HTTPClientSession session(uri.getHost(), uri.getPort());
 
        string path(uri.getPathAndQuery());
        if (path.empty()) path = "/";
 
        HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
        req.set("User-Agent", "Poco");
        //session.setProxy("120.203.215.6", 85);
        session.sendRequest(req);
 
        HTTPResponse res;
        istream &is = session.receiveResponse(res);
        StreamCopier::copyToString(is, text);
        return text;
}
catch(...)
{
        return "";
}
}
 
void PostRequest(string reference, string id)
{
try
{
        string text;
        URI uri(reference);
        HTTPClientSession session(uri.getHost(), uri.getPort());
        session.setKeepAlive(true);
        string path(uri.getPathAndQuery());
        if (path.empty()) path = "/";
 
        HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
        req.setContentType("application/x-www-form-urlencoded");
        req.add("Accept", "text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/        x-xbitmap, */*;q=0.1");
        req.add("Accept-Encoding","gzip,deflate");
        req.setKeepAlive(true);
        req.set("User-Agent", "Opera/9.80 (Windows NT 6.2; WOW64) Presto/2.12.388 Version/12.15");
        req.set("Cookie", "amcu_nn=1; advmaker_pop=1; PHPSESSID=6db1c4beb65ff4346c351459b1caf194");
        std::string reqBody("action=post&lnk="+id);
        req.setContentLength( reqBody.length() );
        session.sendRequest(req) << reqBody;
}
catch(...)
{
cout<<"fail";
}
}

typedef long long ll;
 
// Recursive variant
ll gcd(ll a, ll b)
{
        return (b==0?a:gcd(b,a%b));
}
 
// Not recursive variant
ll gcd(ll a, ll b)
{
        while(a==0 || b==0)
    {
        if(a > b) a = a % b;
        else b = b % a;
    }
        return a + b;
}

#include 
#include 
#include 
using namespace std;
template
class myArray : public vector
{
public:
        void MyUniq();
};
template
void myArray::MyUniq()
{
        sort( this->begin(), this->end() );
        this->erase( unique( this->begin(), this->end() ), this->end() );
        unique (this->begin(), this->end());
}
int main()
{
        myArray q;
        q.push_back(1);
        q.push_back(10);
        q.push_back(2);
        q.push_back(4);
        q.push_back(545);
        q.push_back(1);
        cout<<"do"<
            

#include 
#include 
#include 
 
#include 
 
int main() {
   std::string str = "-3.14asd.asd.a0.23.asdfj234d.123.34++23.0";
   boost::regex rgx("\\-?\\d+\\.\\d+");
   std::copy(
      boost::sregex_token_iterator(str.begin(), str.end(), rgx),
      boost::sregex_token_iterator(),
      std::ostream_iterator (std::cout, " ")
   );
   getchar();
}

#include 
#include 
#include 
using namespace std;
void Func()
{
        cout<<"pFunc()";
}
int main()
{
        typedef void (*pFunc) ();
        vector> vec;
        vec.push_back(make_pair(true, &Func));
        vec.push_back(make_pair(false, &Func));
        for(auto it=vec.begin(); it!=vec.end(); ++it)
        {
                if(it->first) (it->second)();
        }
        getchar();
    return 0;
}

class Foo {
private:
char a;
int b;
float c;
 
public:
Foo() : a('a'), b(10), c(3.5f) {}
};
 
#include 
int main() {
Foo* foo = new Foo();
std::cout«"hello world " « *((float*) ((void*) foo)+2);
delete foo;
return 0;
}

string XOR(string Text)
{   
        int i=0; 
        while(Text[i])
        {
           char mask=(sin(3.14+i)*400)-(cos(3.14+i)*250/20);
           Text[i]=(Text[i]^mask);
           i++;
        }
        return Text;
}

string GetBetween(string target, string left, string right)
{
        size_t begin = target.find(left);
        size_t end = target.find(right);
        if(begin==string::npos || end==string::npos) return "";
        begin += left.size();
        return target.substr(begin, end - begin);
}