std::vector<float> *vector = new std::vector<float>();

9:00-10:00 - music
10:00-(dependent from file) болтовня обычная
(dependent from file)-11:30 - music
11:30-(dependent from file) болтовня
(dependent from file)-12:00 - music

#EXTM3U
#EXTINF:12,джингл1
C:\Users\User\Desktop\РАДИО\джингл1.mp3
#EXTINF:438,Relaxea - Sunshine Delight
Z:\Автоматизация\музыка для радио\Chillout after work\After Work Chillout\001_Relaxea_-_Sunshine_Delight.mp3
#EXTINF:222,Minka - Little Cat
Z:\Автоматизация\музыка для радио\Chillout after work\After Work Chillout\002_Minka_-_Little_Cat.mp3
#EXTINF:962,Богданова
Z:\Радио\Рубрика Наперекор судьбе\Богданова.mp3//болтавня
........

Алгоритм такой:
1.Добавляем в вектора всю музыку и во второй болтавню(рекурсивно обходя директории и их поддиректории)
2.Открываем файл fopen(playlist.m3u8,"w");
Вставляем строку fwrite("#EXTM3U@);
Какой-то функцией определяем длину которая тоже в векторе еще одном будет, либо вектор состоящий из 
struct
{
std::string filename;
float length;
}
3 Подбираем длины чтобы был час по длительности с рандомом по выборке
4. Пишем 
frite("#EXTINF:"+vector[i].length.toString()+","+vector[i].filename);
frite(vector[i].filename);
5. Вставляем из вектора с болтавней одну композицию
frite("#EXTINF:"+vectortalk[i].length.toString()+","+vectortalk[i].filename);
frite(vectortalk[i].filename);
6.Повторяем предыдущие шаги с подборкой длин по расписанию
Well done!

for (int i = 0; i<countdrums; i++)
  {
    glPushMatrix();
    glRotatef(rotate[i], 1, 0, 0);
    for (int j = 0; j<counttextureondrums; j++)
    {
      glBindTexture(GL_TEXTURE_2D, image->IndexTexture[FindTexture(vectordrum[GetMassive(i*j + j)/*randommassive[i*j+j]*/])]);
      EnableTexture(i, j);
    }
    glPopMatrix();
  }

Линейный конгруэнтный генератор Лемера 1951
Наиболее популярным для получения псевдослучайных чисел является
метод вычетов по формуле:

U[i+1] = (U[i]*M)mod p = U[i]*M-p*int(U[i]*M/p)

R[i]=U[i]/p,где U[i],M,p-целые числа,0<R[i]<1,1<=U[i]<=p-1.

#include <iostream>
#include <vector>
const int M = 302;
const int p = 1003;
const float U0 = 0.5;
const int N = 10000;
std::vector<float> gen(float R0, int m, int p)
{
	std::vector<float> R;
	std::vector<float> U;
	U.push_back(R0);
	for (int i = 0; i < N; i++)
	{
		U.push_back(U.back()/*U[i]*/ * M - p*int(U.back()/*U[i]*/ * M / p));
		float r_ = U[i] / p;
		R.push_back(r_);
		std::cout <<R.back()<<" ";
	}
	return R;
}
int main()
{
	gen(U0,M,p);
	std::cin.ignore();
	return 0;
}

Business process, activities that produce a specific service or product for customers
Business process modeling, activity of representing processes of an enterprise in order 
Manufacturing process management, a collection of technologies and methods used to define.
Process architecture, structural design of processes, applies to fields such as computers.
Process costing, a cost allocation procedure of managerial accounting
Process management, ensemble of activities of planning and monitoring the performance of .
Process management (Project Management) , a systematic series of activities directed .
Process-based management, is a management approach that views a business as a collection .
Process industry, a category of material-related industry.

#include <iostream>
#include <vector>
//#include <io.h> 
//#include <stdlib.h>   
typedef unsigned long long uint64_t;
typedef unsigned int uint32_t;
#define N 8
#define F32 0xFFFFFFFF
#define size64 sizeof(uint64_t)
#define ROR(x,n,xsize)((x>>n)|(x<<(xsize-n)))
#define ROL(x,n,xsize)((x<<n)|(x>>(xsize-n)))
#define RKEY(r)((ROR(K,r*3,size64*8))&F32)
const uint64_t K = 0x96EA704CFB1CF672;//base key to forming of round keys
uint32_t RK[N];//massive round keys
const uint64_t IV = 0x296EA704CFB1CF67;
#define CBC 0
#define CFB 0
void createRoundKeys(bool print)
{
	for (int i = 0; i < N; i++)
	{
		RK[i]=(ROR(K, i * 8, size64 * 8))&F32;
		if (print)
			std::cout << "key[" << i << "]=" << std::hex << RK[i] << std::endl;
	}
}
uint32_t F(uint32_t subblk, uint32_t key)
{
	/*
	uint32_t f1 = ROL(subblk, 9, sizeof(subblk) * 8);
	uint32_t f2 = ROR(key, 11, sizeof(key) * 8) | subblk;
	return f1 ^ !f2;
	*/
	return subblk+key;
}
//encryption 64-digit block of message
uint64_t encrypt(uint64_t block, bool print)
{
	//select subblocks
	uint32_t left = (block >> 32)&F32;
	uint32_t right = block&F32;

	uint32_t left_, right_;//subblock in the end of round
	for (int r = 0; r < N; r++)
	{
		if (print)
			std::cout << "round " << r << std::endl << "input blks " << std::hex << left << " " << right << std::endl;
		uint32_t fk = F(left, RK[r]);
		left_ = left;
		right_ = right^fk;
		if (r < N - 1)//swap places to next round
		{
			left = right_;
			right = left_;
		}
		else//last round not swap
		{
			left = left_;
			right = right_;
		}
		if (print)
			std::cout << "round" << r << std::endl << "output blks " << std::hex << left << " " << right << std::endl;
	}
	//collect subblock in block
	uint64_t c_block = left;
	c_block = (c_block << 32) | (right&F32);
	return c_block;
}
//decryption 64-digit block of message
uint64_t decrypt(uint64_t c_block, bool print)
{
	//select subblocks
	uint32_t left = (c_block >> 32)&F32;
	uint32_t right = c_block&F32;

	uint32_t left_, right_;//subblock in the end of round
	for (int r = N-1; r >=0; r--)
	{
		if (print)
			std::cout << "round " << r << std::endl << "input blks " << std::hex << left << " " << right << std::endl;
		uint32_t fk = F(left, RK[r]);
		left_ = left;
		right_ = right^fk;
		if (r > 0)//swap places to next round
		{
			left = right_;
			right = left_;
		}
		else //last round not swap
		{
			left = left_;
			right = right_;
		}
		if (print)
			std::cout << "round" << r << std::endl << "output blks " << std::hex << left << " " << right << std::endl;
	}
	//collect subblock in block
	uint64_t block = left;
	block = (block << 32) | (right&F32);
	return block;
}
#pragma warning(disable:4996)
void main()
{
	std::cout << "Base key\n" <<std::hex<<K<< std::endl;
	std::cout << "\nRound keys:" << std::endl;
	createRoundKeys(false);
	
	
	FILE *fp,*fencrypted,*fdecrypted;
	char str[N];
	if ((fp=fopen("message.txt", "r" ))==NULL) {
		std::cout<<"Cannot open file.\n";
		exit (1);
	}
	
	std::vector<uint64_t> *msg = new std::vector<uint64_t>(),
		*plaintext = new std::vector<uint64_t>();//plain text

	unsigned long long id;
	
	char ch;
	int countbyte = 0;
	std::cout << "Message:\n";
	int countpb1 = 0,ct1=0, countpb2 = 0,ct2=0;
	while ((ch = fgetc(fp)) != EOF)
	{
		if (countbyte % N == 0 && countbyte!=0)
		{
			countbyte = 0;
			memcpy(&id, str, N);
			std::cout << str << std::endl;
			msg->push_back(id);
			countpb1++;
			for (int i = 0; i<N; i++)
				str[i] = '\0';
		}
		str[countbyte] = ch;
		std::cout << str[countbyte];
		countbyte++;
		ct1++;
	}
	memcpy(&id, str, N);
	msg->push_back(id);

	//uint64_t msg = 0xFFAADD11CCBB2299;//plain text

	fclose(fp);
	printf("\nCountPB1=%i\n", countpb1);
	printf("\nCt1=%i\n", ct1);
	if ((fencrypted = fopen("cryptmessage.txt", "w")) == NULL) {
		//printf("Cannot open file.\n");
		std::cout << "Cannot open file.\n";
		exit(1);
	}
	if ((fdecrypted = fopen("message2.txt", "w")) == NULL) {
		//printf("Cannot open file.\n");
		std::cout << "Cannot open file.\n";
		exit(1);
	}
#if CBC == 1 && CFB == 0
	uint64_t iv = IV;
#endif

	int ii = 0;
	for (std::vector<uint64_t>::iterator it = msg->begin(); it != msg->end(); ++it)
	{
		//std::cout << "msg:\n" << std::hex << *it << std::endl;
		//std::cout << "msg:\n" << std::hex << msg << std::endl;
		//uint64_t cipher = encrypt(msg, true);//change on true second parameter when debug, ciphertext
#if CBC == 0 && CFB == 0

		uint64_t cipher = encrypt(msg->at(ii), false);
#endif
#if CBC == 1 && CFB ==0
		cipher = encrypt(msg->at(ii) ^ iv, false);//change on true second parameter when debug, ciphertext
		iv = cipher;
#endif
#if CBC == 0 && CFB == 1
#endif
		//std::cout << "encrypt:\n" << cipher << std::endl;
		memcpy(str, &cipher, N);
		//fwrite(str, N, 1, fencrypted);
		int i = -1;
		while (++i < N/*strlen(str)*/)
		{
			fputc(str[i], fencrypted);
		}
		ii++;
	}
	fclose(fencrypted);
	if ((fencrypted = fopen("cryptmessage.txt", "r")) == NULL) {
		//printf("Cannot open file.\n");
		std::cout << "Cannot open file.\n";
		exit(1);
	}
	countbyte = 0;
	while ((ch = fgetc(fencrypted)) != -1/*EOF*/)
	{
		if (countbyte % N == 0 && countbyte != 0)
		{
			countbyte = 0;
			memcpy(&id, str, N);
			plaintext->push_back(decrypt(id, false));
			countpb2++;
		}
		str[countbyte] = ch;
		std::cout << str[countbyte];
		countbyte++;
		ct2++;
	}
	std::cout << "\nCountPB2=" << countpb2 << "\n";
	printf("\nCt2=%i\n", ct2);
	ii = 0;
	for (std::vector<uint64_t>::iterator it = plaintext->begin(); it != plaintext->end(); ++it)
	{

		//msg = decrypt(cipher, true);//change on true second parameter when debug,plain text
		
		//plaintext->push_back(decrypt(cipher, false));//change on true second parameter when debug,plain text

		memcpy(str, &plaintext->at(ii), N);
		int i = -1;
		while (++i < N/*strlen(str)*/)
		{
			fputc(str[i], fdecrypted);
		}
		//fwrite(str,N,1, fdecrypted);

		//std::cout << "decrypt:\n" << msg<< std::endl;
		std::cout << "decrypt:\n" <<str/*plaintext->at(ii)*/<< "\n--------------------------\n" << std::endl;
		ii++;
	}
	fclose(fencrypted);
	fclose(fdecrypted);
	
	system("pause");
}

FILE *fp,*fencrypted,*fdecrypted;
	char str[N];
	if ((fp=fopen("message.txt", "r" ))==NULL) {
		//printf("Cannot open file.\n");
		std::cout<<"Cannot open file.\n";
		exit (1);
	}
	
	std::vector<uint64_t> *msg = new std::vector<uint64_t>(),
		*plaintext = new std::vector<uint64_t>();//plain text

	unsigned long long id;
	while(!feof (fp)) {
		for (int i = 0; i<N; i++)
			str[i] = '\0';
		if (fgets(str, N, fp))
		{	
			//printf("%s", str);
			std::cout<<str;
			memcpy(&id, str, N);
			msg->push_back(id);
		}
	}

Business process, activities that produce a specific service or product for customers
Business process modeling, activity of representing processes of an enterprise in order 
Manufacturing process management, a collection of technologies and methods used to define.
Process architecture, structural design of processes, applies to fields such as computers.
Process costing, a cost allocation procedure of managerial accounting
Process management, ensemble of activities of planning and monitoring the performance of .
Process management (Project Management) , a systematic series of activities directed .
Process-based management, is a management approach that views a business as a collection .
Process industry, a category of material-related industry.

Business process, activities that produce a specific service or product for customers
Business process modeling, activity of representing processes of an enterprise in order 
Manufacturing process management, a collection of technologies and methods used to define.
Process architecture, structural design of processes, applies to fields such as computers.
Process costing, a cost allocation procedure of managerial accounting
Process management, ensemble of activities of planning and monitoring the performance of .
Process management (Project Management) , a systematic series of activities directed .
Process-based management, is a management approach that views a business as a collection .
Process industry, a category of material-related industry.

Busines s proce ss, act ivities  that p roduce  a speci fic ser vice or  produc t for c ustomer s
      Busines s proce ss mode ling, a ctivity  of rep resenti ng proc esses o f an en terpris e in or der 
   Manufac turing  process  manage ment, a  collec tion of  techno logies  and met hods us ed to d efine.
 Process  archit ecture,  struct ural de sign of  proces ses, ap plies t o field s such  as comp uters.
 Process  costin g, a co st allo cation  procedu re of m anageri al acco unting
 Process  manage ment, e nsemble  of act ivities  of pla nning a nd moni toring  the per formanc e of .
 Process  manage ment (P roject  Managem ent) ,  a syste matic s eries o f activ ities d irected  .
     Process -based  managem ent, is  a mana gement  approac h that  views a  busine ss as a  collec tion .
 Process  indust ry, a c ategory  of mat erial-r elated  industr y.      

#include <iostream>
#include <vector>
#include <fstream>  
//#include <stdlib.h>   
typedef unsigned long long uint64_t;
typedef unsigned int uint32_t;
#define N 8
#define F32 0xFFFFFFFF
#define size64 sizeof(uint64_t)
#define ROR(x,n,xsize)((x>>n)|(x<<(xsize-n)))
#define ROL(x,n,xsize)((x<<n)|(x>>(xsize-n)))
#define RKEY(r)((ROR(K,r*3,size64*8))&F32)
const uint64_t K = 0x96EA704CFB1CF672;//base key to forming of round keys
uint32_t RK[N];//massive round keys
void createRoundKeys(bool print)
{
	for (int i = 0; i < N; i++)
	{
		RK[i]=(ROR(K, i * 8, size64 * 8))&F32;
		if (print)
			std::cout << "key[" << i << "]=" << std::hex << RK[i] << std::endl;
	}
}
uint32_t F(uint32_t subblk, uint32_t key)
{
	/*
	uint32_t f1 = ROL(subblk, 9, sizeof(subblk) * 8);
	uint32_t f2 = ROR(key, 11, sizeof(key) * 8) | subblk;
	return f1 ^ !f2;
	*/
	return subblk+key;
}
//encryption 64-digit block of message
uint64_t encrypt(uint64_t block, bool print)
{
	//select subblocks
	uint32_t left = (block >> 32)&F32;
	uint32_t right = block&F32;

	uint32_t left_, right_;//subblock in the end of round
	for (int r = 0; r < N; r++)
	{
		if (print)
			std::cout << "round " << r << std::endl << "input blks " << std::hex << left << " " << right << std::endl;
		uint32_t fk = F(left, RK[r]);
		left_ = left;
		right_ = right^fk;
		if (r < N - 1)//swap places to next round
		{
			left = right_;
			right = left_;
		}
		else//last round not swap
		{
			left = left_;
			right = right_;
		}
		if (print)
			std::cout << "round" << r << std::endl << "output blks " << std::hex << left << " " << right << std::endl;
	}
	//collect subblock in block
	uint64_t c_block = left;
	c_block = (c_block << 32) | (right&F32);
	return c_block;
}
//decryption 64-digit block of message
uint64_t decrypt(uint64_t c_block, bool print)
{
	//select subblocks
	uint32_t left = (c_block >> 32)&F32;
	uint32_t right = c_block&F32;

	uint32_t left_, right_;//subblock in the end of round
	for (int r = N-1; r >=0; r--)
	{
		if (print)
			std::cout << "round " << r << std::endl << "input blks " << std::hex << left << " " << right << std::endl;
		uint32_t fk = F(left, RK[r]);
		left_ = left;
		right_ = right^fk;
		if (r > 0)//swap places to next round
		{
			left = right_;
			right = left_;
		}
		else //last round not swap
		{
			left = left_;
			right = right_;
		}
		if (print)
			std::cout << "round" << r << std::endl << "output blks " << std::hex << left << " " << right << std::endl;
	}
	//collect subblock in block
	uint64_t block = left;
	block = (block << 32) | (right&F32);
	return block;
}
#pragma warning(disable:4996)
void main()
{
	std::cout << "Base key\n" <<std::hex<<K<< std::endl;
	std::cout << "\nRound keys:" << std::endl;
	createRoundKeys(false);
	
	FILE *fp,*fencrypted,*fdecrypted;
	char str[N];
	if ((fp=fopen("message.txt", "r" ))==NULL) {
		//printf("Cannot open file.\n");
		std::cout<<"Cannot open file.\n";
		exit (1);
	}
	
	std::vector<uint64_t> *msg = new std::vector<uint64_t>(),*plaintext = new std::vector<uint64_t>();//plain text

	unsigned long long id;
	while(!feof (fp)) {
		for (int i = 0; i<N; i++)
			str[i] = '\0';
		if (fgets(str, N, fp))
		{	
			//printf("%s", str);
			std::cout<<str;
			memcpy(&id, str, N);
			msg->push_back(id);
		}
	}
	
	/*
	unsigned long long id; 
	{ 
		std::ifstream in("message.txt"); 
		in >> id; 
		msg->push_back(id);		
	} 
	*/
	//uint64_t msg = 0xFFAADD11CCBB2299;//plain text
	//msg->push_back(0xFFAADD11CCBB2299);
	//msg->push_back(0xFFAADD11CCBB2288);
	//msg->push_back(0xFFAADD11CCBB2277);
	
	fclose(fp);
	int ii=0;
	if ((fencrypted = fopen("cryptmessage.txt", "w")) == NULL) {
		//printf("Cannot open file.\n");
		std::cout << "Cannot open file.\n";
		exit(1);
	}
	if ((fdecrypted = fopen("message2.txt", "w")) == NULL) {
		//printf("Cannot open file.\n");
		std::cout << "Cannot open file.\n";
		exit(1);
	}
	for (std::vector<uint64_t>::iterator it = msg->begin() ; it != msg->end(); ++it)
	{
		std::cout << "msg:\n" << std::hex << *it<< std::endl;
		//std::cout << "msg:\n" << std::hex << msg << std::endl;
		//uint64_t cipher = encrypt(msg, true);//change on true second parameter when debug, ciphertext
		uint64_t cipher = encrypt(msg->at(ii), false);//change on true second parameter when debug, ciphertext
		
		std::cout << "encrypt:\n" << cipher << std::endl;
		memcpy(str, &cipher, N);
		fwrite(str, N,1, fencrypted);
		//msg = decrypt(cipher, true);//change on true second parameter when debug,plain text
		plaintext->push_back(decrypt(cipher, false));//change on true second parameter when debug,plain text

		memcpy(str, &plaintext->at(ii), N);
		fwrite(str,N,1, fdecrypted);

		//std::cout << "decrypt:\n" << msg<< std::endl;
		std::cout << "decrypt:\n" <<plaintext->at(ii)<< "\n--------------------------\n" << std::endl;
		ii++;
	}
	fclose(fencrypted);
	fclose(fdecrypted);
	system("pause");
}

unsigned long long id;
	while(!feof (fp)) {
		for (int i = 0; i<N; i++)
			str[i] = '\0';
		if (fgets(str, N, fp))
		{	
			//printf("%s", str);
			std::cout<<str;
			memcpy(&id, str, N);
			msg->push_back(id);
		}
	}