static int [] TX_int_wav = new int[1500];   
static int [] RX_int_wav = new int[1500];

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////// Key_wav:
static int xK_wav = 0;       //счёт Key_wav 
static int Key_N_wav_ = 0;   //Key_N_wav_ = 0,1,2 -Номер Key  
////////////////////////////////////////K_int_wav[128] 
static int [] K_int_wav = {
////////////////////////////////////////0...7
////////////////vektor_0_wav:  
0,0,0,0,0,0,0,0,
////////////////////////////////////////8...39
////////////////Key_0_wav: 32 байт (256-бит)
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
////////////////////////////////////////40...47
////////////////vektor_1_wav:  
0,0,0,0,0,0,0,0,
////////////////////////////////////////48...79
////////////////Key_1_wav: 32 байт (256-бит)
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
////////////////////////////////////////80...87
////////////////vektor_2_wav:  
0,0,0,0,0,0,0,0,
////////////////////////////////////////88...119
////////////////Key_2_wav: 32 байт (256-бит)
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
////////////////////////////////////////120...127
////////////////Флаги_wav:
0,0,0,0,0,0,
////////////////crc_wav:
0,0
};
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////// Key_String_wav:
static String Key_String_wav = "";
//////////////////////////////////////////////////////////// Key_TX_wav() > LCD:
public static void Key_Str_wav() {   
/////////////////////////////////////// vektor_0_wav > LCD 0...8
Key_String_wav = "V0_wav";
if (Key_N_wav_ == 0){Key_String_wav += " > ";}
else                {Key_String_wav += "    ";};
for (xK_wav=0; xK_wav<8; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
Key_String_wav += " |  ";
/////////////////////////////////////// Key_0_wav: 
for (xK_wav=8; xK_wav<40; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
Key_String_wav += "\r\n";
/////////////////////////////////////// vektor_1_wav > LCD 0...8
Key_String_wav += "V1_wav";
if (Key_N_wav_ == 1){Key_String_wav += " > ";}
else                {Key_String_wav += "    ";};
for (xK_wav=40; xK_wav<48; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
Key_String_wav += " |  ";
///////////////////////////////////////Key_1_wav:
for (xK_wav=48; xK_wav<80; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
Key_String_wav += "\r\n";
///////////////////////////////////////vektor_2_wav > LCD 0...8
Key_String_wav += "V2_wav";
if (Key_N_wav_ == 2){Key_String_wav += " > ";}
else                {Key_String_wav += "    ";};
for (xK_wav=80; xK_wav<88; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
Key_String_wav += " |  ";
///////////////////////////////////////Key_2_wav:
for (xK_wav=88; xK_wav<120; xK_wav++) {        
Key_String_wav += LCD_HEX(K_int_wav[xK_wav]);  
};
}	
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////// vektor_RX_wav:
static int [] vektor_RX_wav = {0,0,0,0,0,0,0,0};  
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// vektor_0_wav:
////////////////////////////////// счёт вектор: 
public static void vektor_0_wav() {   
////////////////////////////////////////0...7
K_int_wav[0] = GS_TX_wav();       
////////////////////////////////////////проверка счёт вектор инициализации:          
if (K_int_wav[1] == 0) { // MAX K_int_wav[x]  
K_int_wav[7]++;
}
////////////////////////////////////////////////
if (K_int_wav[7] > 0xFF) {K_int_wav[7]=0; K_int_wav[6]++;}//счёт вектор инициализации
if (K_int_wav[6] > 0xFF) {K_int_wav[6]=0; K_int_wav[5]++;}//счёт вектор инициализации
if (K_int_wav[5] > 0xFF) {K_int_wav[5]=0; K_int_wav[4]++;}//счёт вектор инициализации
if (K_int_wav[4] > 0xFF) {K_int_wav[4]=0; K_int_wav[3]++;}//счёт вектор инициализации
if (K_int_wav[3] > 0xFF) {K_int_wav[3]=0; K_int_wav[2]++;}//счёт вектор инициализации
if (K_int_wav[2] > 0xFF) {K_int_wav[2]=0; K_int_wav[1]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// vektor_1_wav:
////////////////////////////////// счёт вектор: 
public static void vektor_1_wav() {   
////////////////////////////////////////40...47
K_int_wav[40] = GS_TX_wav();   
//////////////////////////////////////////////// проверка счёт вектор инициализации:          
if (K_int_wav[41] == 0) { // MAX K_int[x] больше   
K_int_wav[47]++;
}
////////////////////////////////////////////////
if (K_int_wav[47] > 0xFF) {K_int_wav[47]=0; K_int_wav[46]++;}//счёт вектор инициализации
if (K_int_wav[46] > 0xFF) {K_int_wav[46]=0; K_int_wav[45]++;}//счёт вектор инициализации
if (K_int_wav[45] > 0xFF) {K_int_wav[45]=0; K_int_wav[44]++;}//счёт вектор инициализации
if (K_int_wav[44] > 0xFF) {K_int_wav[44]=0; K_int_wav[43]++;}//счёт вектор инициализации
if (K_int_wav[43] > 0xFF) {K_int_wav[43]=0; K_int_wav[42]++;}//счёт вектор инициализации
if (K_int_wav[42] > 0xFF) {K_int_wav[42]=0; K_int_wav[41]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// vektor_2_wav:
////////////////////////////////// счёт вектор: 
public static void vektor_2_wav() {   
////////////////////////////////////////40...47
K_int_wav[80] = GS_TX_wav();   
//////////////////////////////////////////////// проверка счёт вектор инициализации:          
if (K_int_wav[81] == 0) { // MAX K_int_wav[x] больше    
K_int_wav[87]++;
}
////////////////////////////////////////////////
if (K_int_wav[87] > 0xFF) {K_int_wav[87]=0; K_int_wav[86]++;}//счёт вектор инициализации
if (K_int_wav[86] > 0xFF) {K_int_wav[86]=0; K_int_wav[85]++;}//счёт вектор инициализации
if (K_int_wav[85] > 0xFF) {K_int_wav[85]=0; K_int_wav[84]++;}//счёт вектор инициализации
if (K_int_wav[84] > 0xFF) {K_int_wav[84]=0; K_int_wav[83]++;}//счёт вектор инициализации
if (K_int_wav[83] > 0xFF) {K_int_wav[83]=0; K_int_wav[82]++;}//счёт вектор инициализации
if (K_int_wav[82] > 0xFF) {K_int_wav[82]=0; K_int_wav[81]++;}//счёт вектор инициализации
}	
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////// Буфер Key:
//Буфер Key 32 байт (256-бит) разбивается на 4 байт (32-бит): K1…K8 
static int [] K1_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K2_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K3_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K4_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K5_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K6_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K7_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K8_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////// Key_0_wav > Буфер Key_wav:
//Key_0 > Буфер Key:  
public static void Key_0_Key_wav() {   
K1_wav[1]=0x45; K1_wav[2]=0xA2; K1_wav[3]=0x81; K1_wav[4]=0x3C;
K2_wav[1]=0x7F; K2_wav[2]=0xC8; K2_wav[3]=0x74; K2_wav[4]=0xCE;
K3_wav[1]=0x83; K3_wav[2]=0x50; K3_wav[3]=0xE6; K3_wav[4]=0x38;
K4_wav[1]=0xF9; K4_wav[2]=0xD5; K4_wav[3]=0x04; K4_wav[4]=0x14;
K5_wav[1]=0x49; K5_wav[2]=0x56; K5_wav[3]=0x63; K5_wav[4]=0x05;
K6_wav[1]=0x20; K6_wav[2]=0x65; K6_wav[3]=0x89; K6_wav[4]=0x53;
K7_wav[1]=0x64; K7_wav[2]=0x40; K7_wav[3]=0x17; K7_wav[4]=0x30;
K8_wav[1]=0x50; K8_wav[2]=0x92; K8_wav[3]=0x86; K8_wav[4]=0x78;
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////// Key_1_wav > Буфер Key_wav:
//Key_1 > Буфер Key:  
public static void Key_1_Key_wav() {   
K1_wav[1]=K_int_wav[48]; K1_wav[2]=K_int_wav[49]; K1_wav[3]=K_int_wav[50]; K1_wav[4]=K_int_wav[51];
K2_wav[1]=K_int_wav[52]; K2_wav[2]=K_int_wav[53]; K2_wav[3]=K_int_wav[54]; K2_wav[4]=K_int_wav[55];
K3_wav[1]=K_int_wav[56]; K3_wav[2]=K_int_wav[57]; K3_wav[3]=K_int_wav[58]; K3_wav[4]=K_int_wav[59];
K4_wav[1]=K_int_wav[60]; K4_wav[2]=K_int_wav[61]; K4_wav[3]=K_int_wav[62]; K4_wav[4]=K_int_wav[63];
K5_wav[1]=K_int_wav[64]; K5_wav[2]=K_int_wav[65]; K5_wav[3]=K_int_wav[66]; K5_wav[4]=K_int_wav[67];
K6_wav[1]=K_int_wav[68]; K6_wav[2]=K_int_wav[69]; K6_wav[3]=K_int_wav[70]; K6_wav[4]=K_int_wav[71];
K7_wav[1]=K_int_wav[72]; K7_wav[2]=K_int_wav[73]; K7_wav[3]=K_int_wav[74]; K7_wav[4]=K_int_wav[75];
K8_wav[1]=K_int_wav[76]; K8_wav[2]=K_int_wav[77]; K8_wav[3]=K_int_wav[78]; K8_wav[4]=K_int_wav[79];
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////// Key_2_wav > Буфер Key_wav:
//Key_2 > Буфер Key:  
public static void Key_2_Key_wav() {   
K1_wav[1]=K_int_wav[88];  K1_wav[2]=K_int_wav[89];  K1_wav[3]=K_int_wav[90];  K1_wav[4]=K_int_wav[91];
K2_wav[1]=K_int_wav[92];  K2_wav[2]=K_int_wav[93];  K2_wav[3]=K_int_wav[94];  K2_wav[4]=K_int_wav[95];
K3_wav[1]=K_int_wav[96];  K3_wav[2]=K_int_wav[97];  K3_wav[3]=K_int_wav[98];  K3_wav[4]=K_int_wav[99];
K4_wav[1]=K_int_wav[100]; K4_wav[2]=K_int_wav[101]; K4_wav[3]=K_int_wav[102]; K4_wav[4]=K_int_wav[103];
K5_wav[1]=K_int_wav[104]; K5_wav[2]=K_int_wav[105]; K5_wav[3]=K_int_wav[106]; K5_wav[4]=K_int_wav[107];
K6_wav[1]=K_int_wav[108]; K6_wav[2]=K_int_wav[109]; K6_wav[3]=K_int_wav[110]; K6_wav[4]=K_int_wav[111];
K7_wav[1]=K_int_wav[112]; K7_wav[2]=K_int_wav[113]; K7_wav[3]=K_int_wav[114]; K7_wav[4]=K_int_wav[115];
K8_wav[1]=K_int_wav[116]; K8_wav[2]=K_int_wav[117]; K8_wav[3]=K_int_wav[118]; K8_wav[4]=K_int_wav[119];
}
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////GS_wav > Key_0_wav:
//GS_wav > Key_0_wav 
public static void GS_Key_0_wav() {   
  ///////////////////////////////////////////// сброс vektor_0_wav
  K_int_wav[0] = 0; K_int_wav[1] = 0; K_int_wav[2] = 0; K_int_wav[3] = 0; 
  K_int_wav[4] = 0; K_int_wav[5] = 0; K_int_wav[6] = 0; K_int_wav[7] = 0;
  ///////////////////////////////////////////// 
  //for (xK_wav=0; xK_wav<32; xK_wav++) {        
  //  K_int_wav[xK_wav+8] = GS_TX_wav();  
  //};
}
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////// GS_wav > Key_1_wav:
//GS_wav > Key_1_wav 
public static void GS_Key_1_wav() {   
  ///////////////////////////////////////////// сброс vektor_1_wav
  K_int_wav[40] = 0; K_int_wav[41] = 0; K_int_wav[42] = 0; K_int_wav[43] = 0;
  K_int_wav[44] = 0; K_int_wav[45] = 0; K_int_wav[46] = 0; K_int_wav[47] = 0;
  ///////////////////////////////////////////// 
  for (xK_wav=0; xK_wav<32; xK_wav++) {        
    K_int_wav[xK_wav+48] = GS_TX_wav();  
  };
}
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////// GS_wav > Key_2_wav:
//GS_wav > Key_2_wav
public static void GS_Key_2_wav() {   
  ///////////////////////////////////////////// сброс vektor_2_wav
  K_int_wav[80] = 0; K_int_wav[81] = 0; K_int_wav[82] = 0; K_int_wav[83] = 0;
  K_int_wav[84] = 0; K_int_wav[85] = 0; K_int_wav[86] = 0; K_int_wav[87] = 0;
  ///////////////////////////////////////////// 
  for (xK_wav=0; xK_wav<32; xK_wav++) {        
    K_int_wav[xK_wav+88] = GS_TX_wav();  
  };
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////// raund_Key_wav:
static int raund_wav = 0;  //номер раунд (Всего 32 раунда) 
static int xraund_wav = 0; //счёт raund 
//Буфер Key: K1...K8 > K
static int [] K_wav = {0x00,0x00,0x00,0x00,0x00};//1...4
//расписание ключей зашифрования 32–З:
//k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k8,k7,k6,k5,k4,k3,k2,k1
public static void KZ_wav() {   
if (raund_wav==0)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K1_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==1)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K2_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==2)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K3_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==3)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K4_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==4)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K5_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==5)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K6_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==6)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K7_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==7)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K8_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	

if (raund_wav==8)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K1_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==9)  {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K2_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==10) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K3_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==11) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K4_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==12) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K5_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==13) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K6_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==14) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K7_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==15) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K8_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	

if (raund_wav==16) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K1_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==17) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K2_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==18) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K3_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==19) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K4_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==20) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K5_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==21) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K6_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==22) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K7_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==23) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K8_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	

if (raund_wav==24) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K8_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==25) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K7_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==26) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K6_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==27) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K5_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==28) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K4_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==29) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K3_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==30) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K2_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
if (raund_wav==31) {for (xraund_wav=4; xraund_wav>0; xraund_wav--) {K_wav[xraund_wav] = K1_wav[xraund_wav];};}//расписание ключей: K1...K8 > K 	
};
//bufer S_блок 
static int bufer_S_blok_1_wav = 0;
static int bufer_S_blok_2_wav = 0;
//строки нумеруются от 0 до 7, столбцы от 0 до F
//S_блок
static int [] S_blok_1_wav = {
0x0F,0x0C,0x02,0x0A,0x06,0x04,0x05,0x00,0x07,0x09,0x0E,0x0D,0x01,0x0B,0x08,0x03 
};
static int [] S_blok_2_wav = {
0x0B,0x06,0x03,0x04,0x0C,0x0F,0x0E,0x02,0x07,0x0D,0x08,0x00,0x05,0x0A,0x09,0x01 
};
static int [] S_blok_3_wav = {
0x01,0x0C,0x0B,0x00,0x0F,0x0E,0x06,0x05,0x0A,0x0D,0x04,0x08,0x09,0x03,0x07,0x02 
};
static int [] S_blok_4_wav = {
0x01,0x05,0x0E,0x0C,0x0A,0x07,0x00,0x0D,0x06,0x02,0x0B,0x04,0x09,0x03,0x0F,0x08 
};
static int [] S_blok_5_wav = {
0x00,0x0C,0x08,0x09,0x0D,0x02,0x0A,0x0B,0x07,0x03,0x06,0x05,0x04,0x0E,0x0F,0x01 
};
static int [] S_blok_6_wav = {
0x08,0x00,0x0F,0x03,0x02,0x05,0x0E,0x0B,0x01,0x0A,0x04,0x07,0x0C,0x09,0x0D,0x06 
};
static int [] S_blok_7_wav = {
0x03,0x00,0x06,0x0F,0x01,0x0E,0x09,0x02,0x0D,0x08,0x0C,0x04,0x0B,0x0A,0x05,0x07 
};
static int [] S_blok_8_wav = {
0x01,0x0A,0x06,0x08,0x0F,0x0B,0x00,0x04,0x0C,0x03,0x05,0x09,0x07,0x0D,0x02,0x0E 
};
//S_блок подстановка:
static int [] bufer_L_wav = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int [] bufer_R_wav = {0x00,0x00,0x00,0x00,0x00}; //1...4
public static void blok_wav() {   
//bufer_R = {0x00,0x01,0x02,0x03,0x04}; //1...4
bufer_S_blok_1_wav = bufer_R_wav[4] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wav = bufer_R_wav[4] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wav = (bufer_S_blok_2_wav >> 4);  //0xF0 > 0x0F; 

bufer_R_wav[4] = S_blok_2_wav[bufer_S_blok_2_wav];   //0xF0;
bufer_R_wav[4] = bufer_R_wav[4]<<4;
bufer_R_wav[4] |= S_blok_1_wav[bufer_S_blok_1_wav];  //0x0F;

bufer_S_blok_1_wav = bufer_R_wav[3] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wav = bufer_R_wav[3] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wav = (bufer_S_blok_2_wav >> 4);  //0xF0 > 0x0F; 

bufer_R_wav[3] = S_blok_4_wav[bufer_S_blok_2_wav];   //0xF0;
bufer_R_wav[3] = bufer_R_wav[3]<<4;
bufer_R_wav[3] |= S_blok_3_wav[bufer_S_blok_1_wav];  //0x0F;

bufer_S_blok_1_wav = bufer_R_wav[2] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wav = bufer_R_wav[2] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wav = (bufer_S_blok_2_wav >> 4);  //0xF0 > 0x0F; 

bufer_R_wav[2] = S_blok_6_wav[bufer_S_blok_2_wav];   //0xF0;
bufer_R_wav[2] = bufer_R_wav[2]<<4;
bufer_R_wav[2] |= S_blok_5_wav[bufer_S_blok_1_wav];  //0x0F;

bufer_S_blok_1_wav = bufer_R_wav[1] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wav = bufer_R_wav[1] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wav = (bufer_S_blok_2_wav >> 4);  //0xF0 > 0x0F; 

bufer_R_wav[1] = S_blok_8_wav[bufer_S_blok_2_wav];   //0xF0;
bufer_R_wav[1] = bufer_R_wav[1]<<4;
bufer_R_wav[1] |= S_blok_7_wav[bufer_S_blok_1_wav];  //0x0F;
};
//Цикличный сдвиг на 11-бит влево  
static int bufer_rol_1_wav = 0;   
static int bufer_rol_2_wav = 0;  
static int bufer_rol_3_wav = 0;   
static int bufer_rol_4_wav = 0;   
//Цикличный сдвиг на 11-бит влево  
public static void rol_wav() {   
bufer_rol_1_wav = bufer_R_wav[1];   
bufer_rol_2_wav = bufer_R_wav[2];   
bufer_rol_3_wav = bufer_R_wav[3];   
bufer_rol_4_wav = bufer_R_wav[4];   

bufer_R_wav[1] =  (bufer_rol_2_wav<<3); 
bufer_R_wav[1] |= (bufer_rol_3_wav>>5);  

bufer_R_wav[2] =  (bufer_rol_3_wav<<3); 
bufer_R_wav[2] |= (bufer_rol_4_wav>>5); 

bufer_R_wav[3] =  (bufer_rol_4_wav<<3);  
bufer_R_wav[3] |= (bufer_rol_1_wav>>5); 

bufer_R_wav[4] =  (bufer_rol_1_wav<<3); 
bufer_R_wav[4] |= (bufer_rol_2_wav>>5); 

bufer_R_wav[1] &= 0x00FF;    
bufer_R_wav[2] &= 0x00FF;   
bufer_R_wav[3] &= 0x00FF;     
bufer_R_wav[4] &= 0x00FF;     
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
static int xGOST_wav = 0; //счёт GOST 
//Входной блок 8 байт (64-бит) 
//N = 0x0102030405060708;  
//Входной блок разбиваем на два блока по 4 байт (32-бит) L и R	
//L = 0x01020304; //L = {0x01,0x02,0x03,0x04};
//R = 0x05060708; //R = {0x05,0x06,0x07,0x08};	
static int [] L_wav = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int [] R_wav = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int LR_wav = 0;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////цикл зашифрования 32–З: 
public static void GOST_Z_wav() {   
///////////////////////////////////////////////////////////// raund 0...30:	
for (raund_wav=0; raund_wav<31; raund_wav++) {		
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_L_wav[xGOST_wav] = L_wav[xGOST_wav];
bufer_R_wav[xGOST_wav] = R_wav[xGOST_wav]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З
KZ_wav();
//bufer_R + K по модулю 32^2:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_R_wav[xGOST_wav] += K_wav[xGOST_wav]; 
LR_wav = (bufer_R_wav[xGOST_wav] >> 8); // 0xFF00
bufer_R_wav[xGOST_wav-1] += LR_wav;
bufer_R_wav[xGOST_wav] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wav();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wav();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_L_wav[xGOST_wav] ^= bufer_R_wav[xGOST_wav]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5:
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
L_wav[xGOST_wav] = R_wav[xGOST_wav]; 
R_wav[xGOST_wav] = bufer_L_wav[xGOST_wav]; 
};
///////////////////////////////////////////
};	     
///////////////////////////////////////////////////////////// raund 31: 
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_L_wav[xGOST_wav] = L_wav[xGOST_wav];
bufer_R_wav[xGOST_wav] = R_wav[xGOST_wav]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З
KZ_wav();
//bufer_R + K сложение по модулю 32^2:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_R_wav[xGOST_wav] += K_wav[xGOST_wav]; 
LR_wav = (bufer_R_wav[xGOST_wav] >> 8); // 0xFF00
bufer_R_wav[xGOST_wav-1] += LR_wav;
bufer_R_wav[xGOST_wav] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wav();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wav();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
bufer_L_wav[xGOST_wav] ^= bufer_R_wav[xGOST_wav]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5: последний раунд не инвертировать !
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wav=4; xGOST_wav>0; xGOST_wav--) {       
//L[xGOST] = R[xGOST]; 
//R[xGOST] = bufer_L[xGOST]; 
L_wav[xGOST_wav] = bufer_L_wav[xGOST_wav]; 
//R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////gamma TX_wav:
static int TX_gamma_st_wav = 0; //счёт gamma TX_wav
////////////////////////////////////////////////////////////шифрования 32–З: TX:
public static void GOST_TX_wav() {   
//Входной блок 8 байт разбиваем на два блока по 4 байт (32-бит) L и R	
//static int [] L = {0x00,0x01,0x02,0x03,0x04}; //1...4
//static int [] R = {0x00,0x05,0x06,0x07,0x08}; //1...4
/////////////////////////////////////////////////////// 
///////////////	Режим простой замены: 
/////////////////////////////////////////////////////// 
//заносится в регистры L и R
L_wav[1] = TX_int_wav[0];  
L_wav[2] = TX_int_wav[1];   
L_wav[3] = TX_int_wav[2];  
L_wav[4] = TX_int_wav[3];  
R_wav[1] = TX_int_wav[4];  
R_wav[2] = TX_int_wav[5];  
R_wav[3] = TX_int_wav[6];  
R_wav[4] = TX_int_wav[7];  
///////////////////////////////////////////////////////  	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z_wav(); // цикл зашифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок простой замены. 
TX_int_wav[0] = L_wav[1];
TX_int_wav[1] = L_wav[2];
TX_int_wav[2] = L_wav[3];
TX_int_wav[3] = L_wav[4];
TX_int_wav[4] = R_wav[1];
TX_int_wav[5] = R_wav[2];
TX_int_wav[6] = R_wav[3];
TX_int_wav[7] = R_wav[4];
/////////////////////////////////////////////////////// 
///////////////	Режим обратной связи по выходу:  
/////////////////////////////////////////////////////// 
/////////////////////////////////////////////////////// vektor: 	
//заносится в регистры L и R
//////////////////////////Key_N_wav == 0
if (Key_N_wav_ == 0){
L_wav[1] = K_int_wav[0];  
L_wav[2] = K_int_wav[1];   
L_wav[3] = K_int_wav[2];  
L_wav[4] = K_int_wav[3];  
R_wav[1] = K_int_wav[4];  
R_wav[2] = K_int_wav[5];  
R_wav[3] = K_int_wav[6];  
R_wav[4] = K_int_wav[7];  
};
//////////////////////////Key_N_wav == 1
if (Key_N_wav_ == 1){
L_wav[1] = K_int_wav[40];  
L_wav[2] = K_int_wav[41];   
L_wav[3] = K_int_wav[42];  
L_wav[4] = K_int_wav[43];  
R_wav[1] = K_int_wav[44];  
R_wav[2] = K_int_wav[45];  
R_wav[3] = K_int_wav[46];  
R_wav[4] = K_int_wav[47];  
};
//////////////////////////Key_N_wav == 2
if (Key_N_wav_ == 2){
L_wav[1] = K_int_wav[80];  
L_wav[2] = K_int_wav[81];   
L_wav[3] = K_int_wav[82];  
L_wav[4] = K_int_wav[83];  
R_wav[1] = K_int_wav[84];  
R_wav[2] = K_int_wav[85];  
R_wav[3] = K_int_wav[86];  
R_wav[4] = K_int_wav[87];  
};
///////////////////////////////////////////////////////  	
for (TX_gamma_st_wav = 8; TX_gamma_st_wav < TX_len_wav; TX_gamma_st_wav = TX_gamma_st_wav + 8) {
/////////////////////////////////////////////////////// 
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z_wav(); // цикл зашифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок гаммы побитно складывается по модулю 2 с блоком открытого текста. 
TX_int_wav[TX_gamma_st_wav]   ^= L_wav[1];
TX_int_wav[TX_gamma_st_wav+1] ^= L_wav[2];
TX_int_wav[TX_gamma_st_wav+2] ^= L_wav[3];
TX_int_wav[TX_gamma_st_wav+3] ^= L_wav[4];
TX_int_wav[TX_gamma_st_wav+4] ^= R_wav[1];
TX_int_wav[TX_gamma_st_wav+5] ^= R_wav[2];
TX_int_wav[TX_gamma_st_wav+6] ^= R_wav[3];
TX_int_wav[TX_gamma_st_wav+7] ^= R_wav[4];
};         
}
////////////////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// GOST_RX_wavr: 
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////// Буфер Key:
//Буфер Key 32 байт (256-бит) разбивается на 4 байт (32-бит): K1…K8 
static int [] K1_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K2_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K3_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K4_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K5_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K6_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K7_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
static int [] K8_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////// Key_0 > Буфер Key:
//Key_0 > Буфер Key:  
public static void Key_0_Key_wavr() {   
K1_wavr[1]=0x45; K1_wavr[2]=0xA2; K1_wavr[3]=0x81; K1_wavr[4]=0x3C;
K2_wavr[1]=0x7F; K2_wavr[2]=0xC8; K2_wavr[3]=0x74; K2_wavr[4]=0xCE;
K3_wavr[1]=0x83; K3_wavr[2]=0x50; K3_wavr[3]=0xE6; K3_wavr[4]=0x38;
K4_wavr[1]=0xF9; K4_wavr[2]=0xD5; K4_wavr[3]=0x04; K4_wavr[4]=0x14;
K5_wavr[1]=0x49; K5_wavr[2]=0x56; K5_wavr[3]=0x63; K5_wavr[4]=0x05;
K6_wavr[1]=0x20; K6_wavr[2]=0x65; K6_wavr[3]=0x89; K6_wavr[4]=0x53;
K7_wavr[1]=0x64; K7_wavr[2]=0x40; K7_wavr[3]=0x17; K7_wavr[4]=0x30;
K8_wavr[1]=0x50; K8_wavr[2]=0x92; K8_wavr[3]=0x86; K8_wavr[4]=0x78;
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////// Key_1 > Буфер Key:
//Key_1 > Буфер Key_wavr:  
public static void Key_1_Key_wavr() {   
K1_wavr[1]=K_int_wav[48]; K1_wavr[2]=K_int_wav[49]; K1_wavr[3]=K_int_wav[50]; K1_wavr[4]=K_int_wav[51];
K2_wavr[1]=K_int_wav[52]; K2_wavr[2]=K_int_wav[53]; K2_wavr[3]=K_int_wav[54]; K2_wavr[4]=K_int_wav[55];
K3_wavr[1]=K_int_wav[56]; K3_wavr[2]=K_int_wav[57]; K3_wavr[3]=K_int_wav[58]; K3_wavr[4]=K_int_wav[59];
K4_wavr[1]=K_int_wav[60]; K4_wavr[2]=K_int_wav[61]; K4_wavr[3]=K_int_wav[62]; K4_wavr[4]=K_int_wav[63];
K5_wavr[1]=K_int_wav[64]; K5_wavr[2]=K_int_wav[65]; K5_wavr[3]=K_int_wav[66]; K5_wavr[4]=K_int_wav[67];
K6_wavr[1]=K_int_wav[68]; K6_wavr[2]=K_int_wav[69]; K6_wavr[3]=K_int_wav[70]; K6_wavr[4]=K_int_wav[71];
K7_wavr[1]=K_int_wav[72]; K7_wavr[2]=K_int_wav[73]; K7_wavr[3]=K_int_wav[74]; K7_wavr[4]=K_int_wav[75];
K8_wavr[1]=K_int_wav[76]; K8_wavr[2]=K_int_wav[77]; K8_wavr[3]=K_int_wav[78]; K8_wavr[4]=K_int_wav[79];
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////// Key_2 > Буфер Key:
//Key_2 > Буфер Keyr:  
public static void Key_2_Key_wavr() {   
K1_wavr[1]=K_int_wav[88];  K1_wavr[2]=K_int_wav[89];  K1_wavr[3]=K_int_wav[90];  K1_wavr[4]=K_int_wav[91];
K2_wavr[1]=K_int_wav[92];  K2_wavr[2]=K_int_wav[93];  K2_wavr[3]=K_int_wav[94];  K2_wavr[4]=K_int_wav[95];
K3_wavr[1]=K_int_wav[96];  K3_wavr[2]=K_int_wav[97];  K3_wavr[3]=K_int_wav[98];  K3_wavr[4]=K_int_wav[99];
K4_wavr[1]=K_int_wav[100]; K4_wavr[2]=K_int_wav[101]; K4_wavr[3]=K_int_wav[102]; K4_wavr[4]=K_int_wav[103];
K5_wavr[1]=K_int_wav[104]; K5_wavr[2]=K_int_wav[105]; K5_wavr[3]=K_int_wav[106]; K5_wavr[4]=K_int_wav[107];
K6_wavr[1]=K_int_wav[108]; K6_wavr[2]=K_int_wav[109]; K6_wavr[3]=K_int_wav[110]; K6_wavr[4]=K_int_wav[111];
K7_wavr[1]=K_int_wav[112]; K7_wavr[2]=K_int_wav[113]; K7_wavr[3]=K_int_wav[114]; K7_wavr[4]=K_int_wav[115];
K8_wavr[1]=K_int_wav[116]; K8_wavr[2]=K_int_wav[117]; K8_wavr[3]=K_int_wav[118]; K8_wavr[4]=K_int_wav[119];
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////// raund_Key:
static int raund_wavr = 0;  //номер раунд (Всего 32 раунда) 
static int xraund_wavr = 0; //счёт raund 
//Буфер Key: K1...K8 > K
static int [] K_wavr = {0x00,0x00,0x00,0x00,0x00};//1...4
//расписание ключей зашифрования 32–З:
//k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k1,k2,k3,k4,k5,k6,k7,k8,k8,k7,k6,k5,k4,k3,k2,k1
public static void KZ_wavr() {   
if (raund_wavr==0)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==1)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==2)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==3)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==4)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==5)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==6)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==7)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	

if (raund_wavr==8)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==9)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==10) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==11) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==12) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==13) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==14) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==15) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
		
if (raund_wavr==16) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==17) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==18) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==19) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==20) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==21) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==22) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==23) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	

if (raund_wavr==24) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==25) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==26) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==27) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==28) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==29) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==30) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==31) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
};
//расписание ключей расшифровывания 32–Р:
//k1,k2,k3,k4,k5,k6,k7,k8,k8,k7,k6,k5,k4,k3,k2,k1,k8,k7,k6,k5,k4,k3,k2,k1,k8,k7,k6,k5,k4,k3,k2,k1
public static void KR_wavr() {   
if (raund_wavr==0)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==1)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==2)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==3)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==4)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==5)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==6)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==7)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	

if (raund_wavr==8)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==9)  {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==10) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==11) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==12) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==13) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==14) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==15) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
			
if (raund_wavr==16) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==17) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==18) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==19) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==20) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==21) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==22) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==23) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
			
if (raund_wavr==24) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K8_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==25) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K7_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==26) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K6_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==27) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K5_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==28) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K4_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==29) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K3_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==30) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K2_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
if (raund_wavr==31) {for (xraund_wavr=4; xraund_wavr>0; xraund_wavr--) {K_wavr[xraund_wavr] = K1_wavr[xraund_wavr];};}//расписание ключей: K1...K8 > K 	
};
//bufer S_блок 
static int bufer_S_blok_1_wavr = 0;
static int bufer_S_blok_2_wavr = 0;
//строки нумеруются от 0 до 7, столбцы от 0 до F
//S_блок
static int [] S_blok_1_wavr = {
0x0F,0x0C,0x02,0x0A,0x06,0x04,0x05,0x00,0x07,0x09,0x0E,0x0D,0x01,0x0B,0x08,0x03 
};
static int [] S_blok_2_wavr = {
0x0B,0x06,0x03,0x04,0x0C,0x0F,0x0E,0x02,0x07,0x0D,0x08,0x00,0x05,0x0A,0x09,0x01 
};
static int [] S_blok_3_wavr = {
0x01,0x0C,0x0B,0x00,0x0F,0x0E,0x06,0x05,0x0A,0x0D,0x04,0x08,0x09,0x03,0x07,0x02 
};
static int [] S_blok_4_wavr = {
0x01,0x05,0x0E,0x0C,0x0A,0x07,0x00,0x0D,0x06,0x02,0x0B,0x04,0x09,0x03,0x0F,0x08 
};
static int [] S_blok_5_wavr = {
0x00,0x0C,0x08,0x09,0x0D,0x02,0x0A,0x0B,0x07,0x03,0x06,0x05,0x04,0x0E,0x0F,0x01 
};
static int [] S_blok_6_wavr = {
0x08,0x00,0x0F,0x03,0x02,0x05,0x0E,0x0B,0x01,0x0A,0x04,0x07,0x0C,0x09,0x0D,0x06 
};
static int [] S_blok_7_wavr = {
0x03,0x00,0x06,0x0F,0x01,0x0E,0x09,0x02,0x0D,0x08,0x0C,0x04,0x0B,0x0A,0x05,0x07 
};
static int [] S_blok_8_wavr = {
0x01,0x0A,0x06,0x08,0x0F,0x0B,0x00,0x04,0x0C,0x03,0x05,0x09,0x07,0x0D,0x02,0x0E 
};
//S_блок подстановка:
static int [] bufer_L_wavr = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int [] bufer_R_wavr = {0x00,0x00,0x00,0x00,0x00}; //1...4
public static void blok_wavr() {   
bufer_S_blok_1_wavr = bufer_R_wavr[4] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wavr = bufer_R_wavr[4] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wavr = (bufer_S_blok_2_wavr >> 4);  //0xF0 > 0x0F; 
	 
bufer_R_wavr[4] = S_blok_2_wavr[bufer_S_blok_2_wavr];   //0xF0;
bufer_R_wavr[4] = bufer_R_wavr[4]<<4;
bufer_R_wavr[4] |= S_blok_1_wavr[bufer_S_blok_1_wavr];  //0x0F;
	 
bufer_S_blok_1_wavr = bufer_R_wavr[3] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wavr = bufer_R_wavr[3] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wavr = (bufer_S_blok_2_wavr >> 4);  //0xF0 > 0x0F; 
	
bufer_R_wavr[3] = S_blok_4_wavr[bufer_S_blok_2_wavr];   //0xF0;
bufer_R_wavr[3] = bufer_R_wavr[3]<<4;
bufer_R_wavr[3] |= S_blok_3_wavr[bufer_S_blok_1_wavr];  //0x0F;
	 
bufer_S_blok_1_wavr = bufer_R_wavr[2] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wavr = bufer_R_wavr[2] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wavr = (bufer_S_blok_2_wavr >> 4);  //0xF0 > 0x0F; 
	
bufer_R_wavr[2] = S_blok_6_wavr[bufer_S_blok_2_wavr];   //0xF0;
bufer_R_wavr[2] = bufer_R_wavr[2]<<4;
bufer_R_wavr[2] |= S_blok_5_wavr[bufer_S_blok_1_wavr];  //0x0F;

bufer_S_blok_1_wavr = bufer_R_wavr[1] & 0x0F;      // = 0x04; 
bufer_S_blok_2_wavr = bufer_R_wavr[1] & 0xF0;      // = 0x04; 
bufer_S_blok_2_wavr = (bufer_S_blok_2_wavr >> 4);  //0xF0 > 0x0F; 
	
bufer_R_wavr[1] = S_blok_8_wavr[bufer_S_blok_2_wavr];   //0xF0;
bufer_R_wavr[1] = bufer_R_wavr[1]<<4;
bufer_R_wavr[1] |= S_blok_7_wavr[bufer_S_blok_1_wavr];  //0x0F;
};
//Цикличный сдвиг на 11-бит влево 
static int bufer_rol_1_wavr = 0;   
static int bufer_rol_2_wavr = 0;  
static int bufer_rol_3_wavr = 0;   
static int bufer_rol_4_wavr = 0;   
//Цикличный сдвиг на 11-бит влево  
public static void rol_wavr() {   
  bufer_rol_1_wavr = bufer_R_wavr[1];   
  bufer_rol_2_wavr = bufer_R_wavr[2];   
  bufer_rol_3_wavr = bufer_R_wavr[3];   
  bufer_rol_4_wavr = bufer_R_wavr[4];   

  bufer_R_wavr[1] =  (bufer_rol_2_wavr<<3); 
  bufer_R_wavr[1] |= (bufer_rol_3_wavr>>5);  

  bufer_R_wavr[2] =  (bufer_rol_3_wavr<<3); 
  bufer_R_wavr[2] |= (bufer_rol_4_wavr>>5); 

  bufer_R_wavr[3] =  (bufer_rol_4_wavr<<3);  
  bufer_R_wavr[3] |= (bufer_rol_1_wavr>>5); 

  bufer_R_wavr[4] =  (bufer_rol_1_wavr<<3); 
  bufer_R_wavr[4] |= (bufer_rol_2_wavr>>5); 

  bufer_R_wavr[1] &= 0x00FF;    
  bufer_R_wavr[2] &= 0x00FF;   
  bufer_R_wavr[3] &= 0x00FF;     
  bufer_R_wavr[4] &= 0x00FF;     
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
static int xGOST_wavr = 0; //счёт GOST 
//Входной блок 8 байт (64-бит) 
//N = 0x0102030405060708;  
//Входной блок разбиваем на два блока по 4 байт (32-бит) L и R	
//L = 0x01020304; //L = {0x01,0x02,0x03,0x04};
//R = 0x05060708; //R = {0x05,0x06,0x07,0x08};	
static int [] L_wavr = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int [] R_wavr = {0x00,0x00,0x00,0x00,0x00}; //1...4
static int LR_wavr = 0;
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////// цикл зашифрования 32–З: 
public static void GOST_Z_wavr() {   
///////////////////////////////////////////////////////////// raundr 0...30:	
for (raund_wavr=0; raund_wavr<31; raund_wavr++) {		
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] = L_wavr[xGOST_wavr];
bufer_R_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З
KZ_wavr();
//bufer_R + K по модулю 32^2:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_R_wavr[xGOST_wavr] += K_wavr[xGOST_wavr]; 
LR_wavr = (bufer_R_wavr[xGOST_wavr] >> 8); // 0xFF00
bufer_R_wavr[xGOST_wavr-1] += LR_wavr;
bufer_R_wavr[xGOST_wavr] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] ^= bufer_R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5:
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
L_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
R_wavr[xGOST_wavr] = bufer_L_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
};	     
///////////////////////////////////////////////////////////// raund 31: 
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] = L_wavr[xGOST_wavr];
bufer_R_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл шифрования 32–З
KZ_wavr();
//bufer_R + K сложение по модулю 32^2:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_R_wavr[xGOST_wavr] += K_wavr[xGOST_wavr]; 
LR_wavr = (bufer_R_wavr[xGOST_wavr] >> 8); // 0xFF00
bufer_R_wavr[xGOST_wavr-1] += LR_wavr;
bufer_R_wavr[xGOST_wavr] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] ^= bufer_R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5: последний раунд не инвертировать !
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
//L[xGOST] = R[xGOST]; 
//R[xGOST] = bufer_L[xGOST]; 
L_wavr[xGOST_wavr] = bufer_L_wavr[xGOST_wavr]; 
//R[xGOST] = R[xGOST]; 
};
///////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////// цикл расшифровывания 32–Р:
public static void GOST_R_wavr() {   
///////////////////////////////////////////////////////////// raund 0...30:	
for (raund_wavr=0; raund_wavr<31; raund_wavr++) {		
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] = L_wavr[xGOST_wavr];
bufer_R_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл расшифровывания 32–Р
KR_wavr();
//bufer_R + K сложение по модулю 32^2:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_R_wavr[xGOST_wavr] += K_wavr[xGOST_wavr]; 
LR_wavr = (bufer_R_wavr[xGOST_wavr] >> 8); // 0xFF00
bufer_R_wavr[xGOST_wavr-1] += LR_wavr;
bufer_R_wavr[xGOST_wavr] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOSTor bufer_L:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] ^= bufer_R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5:
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
L_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
R_wavr[xGOST_wavr] = bufer_L_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
};
///////////////////////////////////////////////////////////// raund 31: 
/////////////////////////////////////////// 0:
//Пункт 0: bufer_L = L, bufer_R = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] = L_wavr[xGOST_wavr];
bufer_R_wavr[xGOST_wavr] = R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 1:
//Пункт 1: 
//расписание ключей: K1...K8 > K // цикл расшифровывания 32–Р
KR_wavr();
//bufer_R + K сложение по модулю 32^2:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_R_wavr[xGOST_wavr] += K_wavr[xGOST_wavr]; 
LR_wavr = (bufer_R_wavr[xGOST_wavr] >> 8); // 0xFF00
bufer_R_wavr[xGOST_wavr-1] += LR_wavr;
bufer_R_wavr[xGOST_wavr] &= 0x00FF;   // 0x00FF
};
//bufer_R[0] = 0; //сброс
///////////////////////////////////////////
/////////////////////////////////////////// 2:
//Пункт 2: производим замену (S-блок):
blok_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 3:
//Пункт 3: производим цикличный сдвиг на 11-бит влево:
rol_wavr();
///////////////////////////////////////////
/////////////////////////////////////////// 4:
//Пункт 4: bufer_L = bufer_R xGOST xor bufer_L:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
bufer_L_wavr[xGOST_wavr] ^= bufer_R_wavr[xGOST_wavr]; 
};
///////////////////////////////////////////
/////////////////////////////////////////// 5: последний раунд не инвертировать !
//Пункт 5: меняем местами R = L, L = R:
for (xGOST_wavr=4; xGOST_wavr>0; xGOST_wavr--) {       
//Lr[xGOST] = Rr[xGOST]; 
//Rr[xGOST] = bufer_Lr[xGOST]; 
L_wavr[xGOST_wavr] = bufer_L_wavr[xGOST_wavr]; 
//Rr[xGOST] = Rr[xGOST]; 
};
///////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////gamma RX_wavr:
static int RX_gamma_st_wavr = 0; //счёт gamma RXr
/////////////////////////////////////////////////////////// расшифрования 32–Р: 
public static void GOST_RX_wavr() {   
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//Входной блок 8 байт разбиваем на два блока по 4 байт (32-бит) L и R	
//static int [] L = {0x00,0x01,0x02,0x03,0x04}; //1...4
//static int [] R = {0x00,0x05,0x06,0x07,0x08}; //1...4
/////////////////////////////////////////////////////// 
///////////////	Режим простой замены:  
/////////////////////////////////////////////////////// 
///////////////////////////////////////////////////////  	
//заносится в регистры L и R
L_wavr[1] = RX_int_wav[0];  
L_wavr[2] = RX_int_wav[1];  
L_wavr[3] = RX_int_wav[2];
L_wavr[4] = RX_int_wav[3];
R_wavr[1] = RX_int_wav[4];
R_wavr[2] = RX_int_wav[5];
R_wavr[3] = RX_int_wav[6];
R_wavr[4] = RX_int_wav[7];
///////////////////////////////////////////////////////  	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
//GOST_Z(); // цикл зашифрования 32–З:
GOST_R_wavr(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//расшифровывания 32–Р:
vektor_RX_wav[0] = L_wavr[1];  
vektor_RX_wav[1] = L_wavr[2];  
vektor_RX_wav[2] = L_wavr[3];
vektor_RX_wav[3] = L_wavr[4];
vektor_RX_wav[4] = R_wavr[1];
vektor_RX_wav[5] = R_wavr[2];
vektor_RX_wav[6] = R_wavr[3];
vektor_RX_wav[7] = R_wavr[4];
/////////////////////////////////////////////////////// 
///////////////	Режим обратной связи по выходу:  
/////////////////////////////////////////////////////// 
///////////////////////////////////////////////////////  	
//заносится в регистры L и R
L_wavr[1] = vektor_RX_wav[0]; 
L_wavr[2] = vektor_RX_wav[1];  
L_wavr[3] = vektor_RX_wav[2];
L_wavr[4] = vektor_RX_wav[3];
R_wavr[1] = vektor_RX_wav[4];
R_wavr[2] = vektor_RX_wav[5];
R_wavr[3] = vektor_RX_wav[6];
R_wavr[4] = vektor_RX_wav[7];
///////////////////////////////////////////////////////  	
for (RX_gamma_st_wavr = 8; RX_gamma_st_wavr < RX_len_wav; RX_gamma_st_wavr = RX_gamma_st_wavr + 8) {
/////////////////////////////////////////////////////// 	
//Содержимое регистров L и R шифруется в соответствии с алгоритмом простой замены. 
GOST_Z_wavr(); // цикл зашифрования 32–З:
//GOST_R(); // цикл расшифровывания 32–Р:
///////////////////////////////////////////////////////  	
//Блок гаммы побитно складывается по модулю 2 с блоком открытого текста. 
RX_int_wav[RX_gamma_st_wavr]   ^= L_wavr[1];
RX_int_wav[RX_gamma_st_wavr+1] ^= L_wavr[2];
RX_int_wav[RX_gamma_st_wavr+2] ^= L_wavr[3];
RX_int_wav[RX_gamma_st_wavr+3] ^= L_wavr[4];
RX_int_wav[RX_gamma_st_wavr+4] ^= R_wavr[1];
RX_int_wav[RX_gamma_st_wavr+5] ^= R_wavr[2];
RX_int_wav[RX_gamma_st_wavr+6] ^= R_wavr[3];
RX_int_wav[RX_gamma_st_wavr+7] ^= R_wavr[4];
};         
}
////////////////////////////////////////////////////////////////////////////////