//#define INFMESSAGE_0 false
   //--------------------------------------------------------------------------
   // Внецентренно-растянутые трубы
   //#define  INFMESSAGE_1
   //#define  DEBUG
   //---------------------------------------------------------------------------
   //  length_XZ - расчетная длина в плоскости стенки
   //  length_YZ - расчетная длина в плоскости поясов
   //  lambdaX - гибкость элемента элемента в плоскости стенки
   //  lambda_x  - условная гибкость элемента элемента в плоскости стенки
   //  lambdaY - гибкость элемента элемента в плоскости поясов
   //  lambda_y - условная гибкость элемента элемента в плоскости поясов
   //---------------------------------------------------------------------------
   if (data_check->index_type == TENSION_BENDING  ) {

	  FI_Y_PARAM Fi_y_param;
      FI_E_PARAM Fi_e_param;
	  double sigma_loc;
	  double lef;
	  double alfa_w, lambda_ux, lambda_uy, Qfic;
	  double excentr;
	  double m_x;  // Эксцентриситет для потери устойчивости из плоскости
	  double m_exc;   // Эксцентриситет для потери устойчивости в плоскости (m)
	  double Wc, Wt; // минимальный момент сопротивления, соответствующий более сжатому и растянутому поясу
	  double sig_1, sig_2;
	  double sig_1w, sig_2w;
	  double lambda_uw;
	  double lambda_uw_[100]; // наибольшая условная гибкость стенки при центральном сжатии
	  double lambda_uf_[100]; // наибольшая условная гибкость поясов
	  double tau_m, tau_y;
	  double hd, Ad, Ad_[100], delta_fi, Ar, lambda_uw20, lambda_uw1, lambda_uw2;
	  bool flag_check[30];
	  double krit_1, krit_2;
	  double Af1, Nf1, Af2, Nf2;
	  double alfa_x, alfa_y, alfa_y0, k_, k_x, fi_m;
	  //double fi_f1, fi_f2;
	  double M_c;
	  double lambda_cent; // гибкость при центральном сжатии
	  int    index_105 = 1;
	  double length, lambda, i_f;
	  int j_, m, k, list_RSU[10];
	  double x_;
	  int n_elem; // текущий номер элемента
	  int n_elem_rep;        // текущий номер элемента выводимый в отчет
	  int i;
	  char stroka[120];
	  double Wx_min, Wy_min, cx_, cy_, n_, beta;
	  double sig_N, sig_M, sig_ext, sig_int, sig_M_y, sig_sum;
	  double krit_0;
	  double NatMmax, Mc_at;
	  double N_at6, c_at6, fy_at6, M_at6, Mc_at6, Ar_at6;
	  double N_at5, fy_at5, M_at5, Ar_at5;
	  double c_at5, fe_at5, lambda_uw_at5;
	  CHECK_ELEM_PARAM_U *Cp;
	  CHECK_ELEM_PARAM_CB_U *Cp_cb;
	  double krit_8_5_8max = -1;
	  int  elem_8_5_8;
	  SECT_DVUTAVR Sect_Elem_Copy;
	  double fi_exy = 0;
	  double alfa_sig;   // (sig1-sig2)/sig1;
	  double Q_1, tau_max, sig_max;
	  bool flag_Ad;
	  double krit_5, krit_6;
;
	  int index_flex_1_const;
	  double lambda_uw_m;

	  double krit_max = 0;
	  int RSU_max = 0;



	  Cp = &(Check_param);
	  Cp_cb = &(Check_param_cb);
	  #ifdef INFMESSAGE_0
		InfMessage("Проверки растянуто-изгибаемых элементов");
		InfMessage("================================================");
	  #endif
	  for (i=0; i<data_check->num_krit; i++)
		  flag_check[i] = data_check->Checked[i];

	  // Зануление критериев
	  for (i=0; i<data_check->num_krit; i++) {
		krit[i] = -1;
		nnel_krit[i] = -1;
	  }
	  // Вычисление sigma_loc, ф.47 СП

	  sigma_loc = 0;


	  //InfMessage("lambda_w = "+FloatToStr(Round(lambda_w, 3)));

	  double Mmax = 0;
	  double Qmax = 0;
	  double Nmax = 0;
	  double alfa_yf1_max = 0;
	  double alfa_yf2_max = 0;
	  double Nf1_min = 0;
	  double Nf2_min = 0;
	  double N1_at_min, M1_at_min, N2_at_min, M2_at_min, Ar1_at_min, Ar2_at_min, Z1_at_min, Z2_at_min;
	  N1_at_min = M1_at_min = N2_at_min = M2_at_min = Ar1_at_min = Ar2_at_min = Z1_at_min = Z2_at_min = 0;


	  Cp->sigma_max = 0;
	  Cp->tau_max = 0;
	  Cp->tau_y_max = 0;
	  Cp->n_RSU = 3;
	  Cp->alfa_f = Af/(t_*h_);

	  krit_0 = 0;
	  Cp->hef1 = 0;
	  Cp->hw1 = 0;

	  index_105 = 1;
	  cx_ = 1;
	  cy_ = 1;
	  n_ = 1;

	  //prinm0("Elem_RSU 1", NRSU, 6, Elem_RSU );
	  //InfMessage("----------------------- Проверка сжато-изгибаемых элементов");
	  //nfMessage("Ugol_var = " + FloatToStr(Round(data_check->ugol_var, 2)));

	  for (i = 0; i<NRSU; i++) {
		  n_elem = ListElem_RSU[i];
		  // Проверка задания шага раскреплений
		  if (data_check->step_ext[n_elem] == 0 || data_check->step_int[n_elem]==0) {
			data_check->step_ext[n_elem] = data_check->step_int[n_elem] = data_check->length_YZ[n_elem];

			// krit[0] = 101;
			//*n_krit = 1;
			//return 0;
		  }

		  n_elem_rep = n_elem;
		  if (!CheckElem[i][4])
			continue;

	  // Вычисление fi_y (коэффициент устойчивости в плоскости поясов при центальном сжатии) выполняется в CheckExecute
	  // Вычисление fi_x (коэффициент устойчивости в плоскости стенки при центальном сжатии) выполняется в CheckExecute
   	  // Значение условной предельной гибкости стенки при центальном сжатии
		lambda_uw_[n_elem] = Fun_lambda_uw_cent(Sect_Elem_Group[ngroup].type_sect, lambda_x[n_elem]);
	  // Значение условной предельной гибкости в плоскости поясов при центральном сжатии
		lambda_uf_[n_elem] = Fun_lambda_uf_cent(Sect_Elem_Group[ngroup].type_sect, lambda_y[n_elem]);

		  if (fi_y[n_elem] < fi_x[n_elem])
			 lambda_cent = lambda_y[n_elem];
		  else
			 lambda_cent = lambda_x[n_elem];


		  memcpy((char*) &Sect_Elem_Copy, (char*)&(Sect_Elem_Group[0].com_sect.dvutavr), sizeof(SECT_DVUTAVR));
		  // Установить текущую высоту стенки элемента
		  //Sect_Elem_All[n_elem].com_sect.dvutavr.h = H_sten[n_elem][ListNSect_RSU[i]];

		  //  Вычисление параметров конструктивного элемента по сечению
		  //--------------------------------------------------------------------------
		  // Вычислить геометрические характеристики сечения группы
		  Get_param_sect_comm(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), &param_sect);
		  if (param_sect.Izz < 1e0) {
			#ifdef EMBRAC
			rc = Application->MessageBox(L"Программная ошибка Check_Execute%Compression_Bending: Izz = 0",L"Сжато-изгибаемые элементы",
			   MB_OK | MB_ICONERROR);
			#else
			rc = Application->MessageBox("Программная ошибка Check_Execute%Compression_Bending: Izz = 0","Сжато-изгибаемые элементы",
			   MB_OK | MB_ICONERROR);
			#endif
			return rc;
		  }
		  if (data_check->flag_netto) {
			Get_param_sect_netto(&(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto,
						   data_check->diametr, data_check->num_holes, data_check->space, data_check->step);
		  }
		  else {
			memcpy((char*)&param_netto, (char*)&param_sect, sizeof(GEOM_PARAM_SECT));
		  }
		  i_zz = sqrt(param_sect.Izz/param_sect.Ar);
		  i_yy = sqrt(param_sect.Iyy/param_sect.Ar);
		  // Гибкость элемента
		  lambdaX[n_elem] = data_check->length_XZ[n_elem]/i_zz;
		  lambdaY[n_elem] = data_check->length_YZ[n_elem]/i_yy;
		  // Условная гибкость элемента
		  lambda_x[n_elem] = lambdaX[n_elem]*sqrt(Ry/Ey);     // в плоскости стенки                                                     *
		  lambda_y[n_elem] = lambdaY[n_elem]*sqrt(Ry/Ey);     // в плоскости поясов

		  Af = MIN(bef_1*tef_1, bef_2*tef_2);   // меньшая площадь пояса
		  Aw = t_*h_;

		  lambda_w = (hef/t_)*sqrt(Ry/Ey);
		  // Вычисление fi_y - коэффициент устойчивости в плоскости поясов при центальном сжатии
		  fi_y[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_y[n_elem]), 3);
		  // Вычисление fi_x коэффициент устойчивости в плоскости стенки при центальном сжатии
		  fi_x[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_x[n_elem]), 3);
		  //InfMessage("fi_x="+FloatToStr(fi_x)+"lambda_x="+FloatToStr(lambda_x));

		  Wx_min = MIN(param_netto.Izz/param_netto.Zct, param_netto.Izz/(param_netto.Hsect - param_netto.Zct));
		  Wy_min = MIN(param_netto.Iyy/param_netto.Yct, param_netto.Iyy/(param_netto.Wsect - param_netto.Yct));

		  N_ = Elem_RSU[i][0]*1000;
		  Q_ = Elem_RSU[i][3]*1000;
		  M_ = Elem_RSU[i][2]*1e6;
		  M_y = Elem_RSU[i][4]*1e6;

		  if (Cp->hef1 == 0) {
			Cp->hef1 = hef;
			Cp->hw1 = h_;
			Cp_cb->hef1 = hef;
			Cp_cb->hw1 = h_;
		  }
		  Cp->hef2 = hef;   // Будет последнее, несмотря на жесткие вставки
		  Cp->hw2 = h_;
		  Cp_cb->hef2 = hef;   // Будет последнее, несмотря на жесткие вставки
		  Cp_cb->hw2 = h_;

	   // sprintf(stroka,"M_=%8.1f", Elem_RSU[i][2]);
	   // InfMessage("Tens-Bend="+(AnsiString)stroka);

		  if (data_check->M_third > 0.1 && (ABS(Elem_RSU[i][2])) > data_check->M_third)
			M_c = data_check->M_third*1e6*SIGN(M_);
		  else
			M_c = M_;

	   // for (m=0; m<6; m++) {
	   //   result_check->RSU[j_][k][m] = Elem_RSU[i][m];
	   // }
	   // result_check->RSU[j_][k][m] = M_c*1e-6;

		  Forces[0] = Elem_RSU[i][0]*1000;
		  Forces[1] = Elem_RSU[i][1]*1e6;
		  Forces[2] = Elem_RSU[i][2]*1e6;
		  Forces[3] = Elem_RSU[i][3]*1000;
		  Forces[4] = Elem_RSU[i][4]*1e6;
		  Forces[5] = Elem_RSU[i][5]*1000;

		// Минимальное и максимальное напряжение в стенке
		  sig_1 = N_/param_sect.Ar + M_*(param_sect.Zct - tef_1 - param_sect.Rad)/param_sect.Izz;
		  sig_2 = N_/param_sect.Ar - M_*(param_sect.Hsect - param_sect.Zct - tef_2 - param_sect.Rad)/param_sect.Izz;
		  sig_1w = MIN(sig_1, sig_2);
		  sig_2w = MAX(sig_1, sig_2);

		  alfa_w = (sig_1w - sig_2w)/sig_1w;
		// Вычисление напряжений
		  sigma_beam_comm(&param_sect, Forces, sigma_comm);

		  if (sigma_comm[0] < sigma_comm[2]) {
			Wc = param_sect.Izz/param_sect.Zct;
			Wt = param_sect.Izz/(param_sect.Hsect - param_sect.Zct);
		  }
		  else  {
			Wc = param_sect.Izz/(param_sect.Hsect - param_sect.Zct);
			Wt = param_sect.Izz/param_sect.Zct;
		  }

		  if (N_ != 0) {
			excentr = ABS(M_/N_);
			m_exc = excentr*param_sect.Ar/Wc;  // для устойчивости в плоскости момента

			excentr = ABS(M_c/N_);
			m_x = excentr*param_sect.Ar/Wc;  // для устойчивости из плоскости момента
		  }
		  else {
			m_x = 20;
			m_exc = 20;
		  }

		// Вычисление fi_e - устойчивость в плоскости действия момента
		  Get_fi_e(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_, N_, 0,
				   data_check->length_XZ[n_elem], &param_sect, Ry, Ey, &Fi_e_param);

		// Вычисление fi_b
		  double fi_b = Get_fi_b_centr(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_c, N_,
						data_check->length_YZ[n_elem], data_check->step_ext[n_elem], data_check->step_int[n_elem],
						&param_sect, Ry, Ey);

		// Вычисление fi_y для изгибаемых элементов
		  Get_c_fi_y(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_c, N_,
					   data_check->length_YZ[n_elem], data_check->step_ext[n_elem], data_check->step_int[n_elem],
					   &param_sect, Ry, Ey, &Fi_y_param, fi_b);

		  if (fi_b <=1e-2 || Fi_y_param.fi_y <=1e-2 || Fi_y_param.c_ <=1e-2 || Fi_e_param.fi_e <=1e-2) {
			   #ifdef EMBRAC
			   rc = Application->MessageBox(L"Программная ошибка Check_Execute%Compression_Bending: fi <= 1e-2",L"Сжато-изгибаемые элементы",
			   MB_OK | MB_ICONERROR);
			#else
			   rc = Application->MessageBox("Программная ошибка Check_Execute%Compression_Bending: fi <= 1e-2","Сжато-изгибаемые элементы",
			   MB_OK | MB_ICONERROR);
			#endif
			return rc;
		  }

		  #ifdef INFMESSAGE_00
		  InfMessage(" N_= " + FloatToStr(Round(N_*1e-3, 2)) + "; M_ =" + FloatToStr(Round(M_*1e-6,2)));
		  InfMessage(" Fi_y_param.c_ " + FloatToStr(Round(Fi_y_param.c_, 3)) +"; Fi_y_param.fi_y" +
					FloatToStr(Round(Fi_y_param.fi_y, 3)) + "; Fi_e_param.fi_e" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
		  #endif

		  alfa_x = (ABS(N_))/(Fi_e_param.fi_e*param_sect.Ar*Ry*data_check->gamma_c);
		  alfa_y = (ABS(N_))/(Fi_y_param.c_*Fi_y_param.fi_y*param_sect.Ar*Ry*data_check->gamma_c);
		  alfa_y0 = (ABS(N_))/(Fi_y_param.fi_y*param_sect.Ar*Ry*data_check->gamma_c);
		  lambda_ux = data_check->Limit_lambda1 - data_check->Limit_lambda2*(MAX(0.5, alfa_x));
		  lambda_uy = data_check->Limit_lambda1 - data_check->Limit_lambda2*(MAX(0.5, alfa_y0));
		  // Вычисление k_x
		  if (lambdaX[n_elem]/lambda_ux <= alfa_x || lambdaY[n_elem]/lambda_uy <= alfa_y)
			k_x = 1.0;
		  else {
			fi_m = MIN(Fi_e_param.fi_e, Fi_y_param.c_*Fi_y_param.fi_y);
			if ((ABS(N_)) <= 1e-1)
			   k_x = 1.25;
			else
			   k_x = MIN(sqrt(fi_m*param_sect.Ar*Ry/(ABS(N_))), 1.25);
		  }
		  // Предельная условная гибкость стенки lambda_uw при mx=20 (как для изгибаемого элемента) по п. 8.5.8
		  lambda_uw20 = Fun_lambda_uw20(M_, Q_, Ry, Ry, Ey, Rs, hef, t_, Af, data_check->gamma_c);

		  // Среднее касательное напряжение
		  tau_m = (ABS(Q_))/(h_*t_);
		  // c*fi_y - fi_e
		  delta_fi = Fi_y_param.c_*Fi_y_param.fi_y - Fi_e_param.fi_e;
		  // Предельная условная гибкость стенки по табл. 22

		  lambda_uw = Fun_lambda_uw_cent_bend(type_sect, lambda_x[n_elem], m_exc, sig_1w, sig_2w, tau_m, delta_fi,
					Ry, data_check->gamma_c, lambda_uw20);
		  lambda_uw1 = Fun_lambda_uw_cent_bend(type_sect, lambda_x[n_elem], m_exc, sig_1w, sig_2w, tau_m, 1.0,
					Ry, data_check->gamma_c, lambda_uw20);
		  lambda_uw2 = Fun_lambda_uw_cent_bend(type_sect, lambda_x[n_elem], m_exc, sig_1w, sig_2w, tau_m, -1.0,
					Ry, data_check->gamma_c, lambda_uw20);

		  #ifdef INFMESSAGE
		  InfMessage(IntToStr(i+1)+": N ="+FloatToStr(Round(N_/1000, 1))+", M ="+FloatToStr(Round(M_/1e6, 1)));
		  InfMessage("     lambda_uw20 ="+FloatToStr(lambda_uw20)+", lambda_uw ="+FloatToStr(Round(lambda_uw, 3)));
		  #endif
		  hd = MIN(hef, t_*(lambda_uw - (lambda_w/lambda_uw - 1)*(lambda_uw - 1.2 - 0.15*(MIN(lambda_x[n_elem], 3.5))))*sqrt(Ey/Ry));
		  // Редуцированная площадь
		  Ad = param_sect.Ar - (hef - hd)*t_;
		  //------------------------------------------------------
		  // 1. (2.2.8)
		  // Расчет на прочность по нормальным напряжениям, п. 9.1.1 ф.(105) или (106)
		  //-------------------------------------------------------------------
		  if (flag_check[0]) {
			double krit_8_5_8, krit_8_5_18;
			double krit_105, krit_106;
			//--------------------------------------------------------------------------
			// Условие п. 8.5.8
			{
			  double alfa, sig1, sig2, A1, A2, h1, Dev;

			  tau_m = (ABS(Q_))/(t_*h_);
			  alfa = Fun_alfa_18(lambda_w, tau_m/Rs);

			  if (bef_1 == bef_2 && tef_1 == tef_2) {
				// симметричное сечение
				krit_8_5_8 = (ABS(M_))/(Ry*data_check->gamma_c*hef*hef*t_*(bef_1*tef_1/(h_*t_) + alfa));
			  }
			  else { // моносимметричное сечение
				if (sigma_comm[0]<0) {
				  sig1 = MIN((ABS(sigma_comm[0])), Ry);
				  sig2 = MIN((ABS(sigma_comm[2])), Ry);
				  A1 = bef_1*tef_1;
				  A2 = bef_2*tef_2;
				}
				if (sigma_comm[2]<0) {
				  sig1 = MIN((ABS(sigma_comm[2])), Ry);
				  sig2 = MIN((ABS(sigma_comm[0])), Ry);
				  A1 = bef_2*tef_2;
				  A2 = bef_1*tef_1;
				}
				//t и tw в формуле 87 равны
				h1 = h_*t_/(2*t_)+(A2*sig2 - A1*sig1)/(2*t_*sqrt(Ry*Ry-3*tau_m*tau_m));
				Dev = sig1*A1*h1 + sig2*A2*(h_ - h1)+4*h1*h1*t_*alfa*Ry +
					 h_*t_*(h_ - 2*h1)*sqrt(Ry*Ry-3*tau_m*tau_m)*0.5;
				krit_8_5_8 = (ABS(M_))/(Dev*data_check->gamma_c);
			  }
			  if (krit_8_5_8max < krit_8_5_8) {
				krit_8_5_8max = krit_8_5_8;
				elem_8_5_8 = n_elem_rep;
			  }
			}
		   //-----------------------------------------------------------------
		   // Проверка местной устойчивости сжатого пояса, п. 8.5.18.
			{
			  double lambda_f, lambda_uf, sig_f1, sig_f2;
			  double s1, s2;
			  krit_8_5_18 = 0;
			  sig_f1 = N_/param_netto.Ar - M_*(param_netto.Zct)/param_netto.Izz;
			  sig_f2 = N_/param_netto.Ar + M_*(param_netto.Hsect - param_netto.Zct)/param_netto.Izz;
			  s1 = MIN(sig_f1, sig_f2);
			  s2 = MAX(sig_f1, sig_f2);
			  alfa_sig = (s1 - s2)/s1;
			  sig_max = MAX((ABS(sig_f1)), (ABS(sig_f2)));
			  if (sig_f1 < 0 ) {
				lambda_uf = 0.5*sqrt(Ry/(ABS(sig_f1)));
				krit_8_5_18 = lambda_f1/lambda_uf;
			  }
			  if (sig_f2 < 0 ) {
				lambda_uf = 0.5*sqrt(Ry/(ABS(sig_f2)));
				krit_8_5_18 = MAX(krit_8_5_18, lambda_f2/lambda_uf);
			  }
			}
			tau_m = (ABS(Q_))/(t_*h_);
			tau_y = 0;
			sig_N = (ABS(N_))/param_netto.Ar;

		  // По умолчанию пластика не допускается, должна использоваться ф. 106
			index_105 = 0;
		  // Условия применимости ф. 105 (index_105 = 1)
		  // Условие п. 9.1.1
			if (steel_param.Ryn <= 440 && data_check->index_class != 1 &&
			   tau_m < 0.5*Rs && !data_check->flag_dynamic_load &&
			   sig_N > 0.1*Ry) {

			   index_105 = 1;
			}
		  // Если sig_N <= 0.1*Ry
			if (steel_param.Ryn <= 440 && data_check->index_class != 1 &&
				tau_m < 0.5*Rs && !data_check->flag_dynamic_load &&
				sig_N <= 0.1*Ry) {
				// Если выполняются условия п. 8.5.8 и 8.5.18
				if (krit_8_5_8 <= 1.0 && krit_8_5_18 <=1.0)

				  index_105 = 1;
			}
		  //--------------------------------------------------------------------------------
		  // Применение ф. 105
			if (index_105 == 1) {  // Формула 105
			  double alfa_f;
			  //  n_elem
			  beta = 1;
			  // Получить значение коэффициентов n, cx, cy по табл Е.1
			  Get_n_cx_cy(0, Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), &n_, &cx_, &cy_);

			  sig_N = (ABS(N_))/param_netto.Ar;
			  sig_M = (ABS(M_))/(cx_*beta*Wx_min);
			  sig_M_y =(ABS(M_y))/(cy_*Wy_min);

			  // Критерий по ф. 105
			  krit_105 = pow(sig_N/(Ry*data_check->gamma_c), n_) + sig_M/(Ry*data_check->gamma_c) +
			  sig_M_y/(Ry*data_check->gamma_c) ;

			  if (krit[0] < krit_105) {
				krit[0] = krit_105;
				nnel_krit[0] = n_elem_rep;
			  }
			  // InfMessage("Формула 105: n_elem="+IntToStr(n_elem)+", N ="+FloatToStr(Round(N_/1000, 1))+
			  //             ", M ="+FloatToStr(Round(M_/1e6, 1))+
			  //             ", M_y ="+FloatToStr(Round(M_y/1e6, 1))+ "n_="+FloatToStr(Round(n_, 2))+
			  //            "cx_="+FloatToStr(Round(cx_, 2))+ "cy_="+FloatToStr(Round(cy_, 2)));

			  if (krit[0] > krit_0) {
				krit_0 = krit[0];
				#ifdef INFMESSAGE
				if (n_elem == 28 || n_elem == 27) {
				InfMessage("Формула 105: n_elem="+IntToStr(n_elem)+", N ="+FloatToStr(Round(N_/1000, 1))+
						   ", M ="+FloatToStr(Round(M_/1e6, 1))+
						   ", M_y ="+FloatToStr(Round(M_y/1e6, 1))+ "n_="+FloatToStr(Round(n_, 2))+
						  "cx_="+FloatToStr(Round(cx_, 2))+ "cy_="+FloatToStr(Round(cy_, 2)));
				InfMessage("sig_N ="+FloatToStr(Round(sig_N,1))+", sig_M ="+FloatToStr(Round(sig_M,1))+
					 ", sig_M_y ="+FloatToStr(Round(sig_M_y,1)));
				InfMessage("krit_0 =" + FloatToStr(Round(krit_0, 2)));
				}
				#endif
			  }
			}
			else {   // Применение ф. 106
			  sig_N = N_/param_netto.Ar;
			  sig_ext = sig_N  - M_*param_sect.Zct/param_netto.Izz;
			  sig_int = sig_N + M_*(param_sect.Hsect - param_sect.Zct)/param_netto.Izz;
			  sig_M_y =(ABS(M_y))/Wy_min;
			  sig_sum = MAX((ABS(sig_ext + sig_M_y)), (ABS(sig_ext - sig_M_y)));
			  sig_sum = MAX(sig_sum, (ABS(sig_int + sig_M_y)));
			  sig_sum = MAX(sig_sum, (ABS(sig_int - sig_M_y)));


			  krit_106 = sig_sum/(Ry*data_check->gamma_c);
			  if (krit[0] < krit_106) {
				krit[0] = krit_106;
				nnel_krit[0] = n_elem_rep;
			  }
			  //InfMessage("Формула 106: n_elem="+IntToStr(n_elem)+", N ="+FloatToStr(Round(N_/1000, 1))+", M ="+FloatToStr(Round(M_/1e6, 1))+
			  //       ", M_y ="+FloatToStr(Round(M_y/1e6, 1)));

			  if (krit[0] > krit_0) {
				krit_0 = krit[0];
				#ifdef INFMESSAGE
				if (n_elem == 28 || n_elem == 27) {
				InfMessage("Формула 106: n_elem="+IntToStr(n_elem)+", N ="+FloatToStr(Round(N_/1000, 1))+", M ="+FloatToStr(Round(M_/1e6, 1))+
					 ", M_y ="+FloatToStr(Round(M_y/1e6, 1)));
				InfMessage("Ar = " + FloatToStr(param_netto.Ar) + "; Zct = " + FloatToStr(param_sect.Zct) + "; param_netto.Izz = " +
									 FloatToStr(param_sect.Izz));
				InfMessage("sig_N ="+FloatToStr(Round(sig_N,1))+", sig_ext ="+FloatToStr(Round(sig_ext,1))+
						   ", sig_int ="+FloatToStr(Round(sig_int,1))+ ", sig_sum ="+FloatToStr(Round(sig_sum,1)));
				InfMessage("krit_0 =" + FloatToStr(Round(krit_0, 2)));
				}
				#endif
			  }
			}
		  }
		  memcpy((char*)&(Sect_Elem_Group[0].com_sect.dvutavr), (char*) &Sect_Elem_Copy, sizeof(SECT_DVUTAVR));
		// Вычисление максимального касательного напряжения
		  Qfic = GetQfic(Ey, Ry, N_, fi_x[n_elem]);        // - используется коэффициент fi_x, полученный для центрального сжатия
		  Q_1 = MAX((ABS(Q_)), Qfic);

		  tau_max = Calc_Tau_Pop_Force(N_, M_, Q_1, &(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto, data_check->ugol_var);
		  if (N_ > Nmax) {

			Nmax = N_;
			Cp->RSU[0][0] = Elem_RSU[i][0];
			Cp->RSU[0][2] = Elem_RSU[i][2];
			Cp->RSU[0][3] = Elem_RSU[i][3];
			Cp->RSU[0][4] = Elem_RSU[i][4];
			Cp->RSU[0][5] = Elem_RSU[i][5];
			Cp->RSU[0][6] = M_c*1e-6;

			Cp_cb->nelem = n_elem_rep;
			Cp_cb->hw = h_;
			Cp_cb->hef = hef;
			Cp_cb->bef = bef_1;
			Cp->hsect = h_;
			Cp->bsect = b_;

			Cp_cb->lambdaX = lambdaX[n_elem];
			Cp_cb->lambdaY = lambdaY[n_elem];
			Cp_cb->lambda_x = lambda_x[n_elem];
			Cp_cb->lambda_y = lambda_y[n_elem];
			Cp_cb->lambda_w = lambda_w;
			Cp_cb->lambda_uw = lambda_uw;
			Cp_cb->lambda_f1 = lambda_f1;
			Cp_cb->lambda_f2 = lambda_f2;
			//Cp_cb->lambdaBF1 = Lambda_f1Y[n_elem];
			//Cp_cb->lambda_bf1 = lambda_f1Y[n_elem];
			//Cp_cb->lambdaBF2 = Lambda_f2Y[n_elem];
			//Cp_cb->lambda_bf2 = lambda_f2Y[n_elem];
			Cp_cb->fi_x = fi_x[n_elem];
			Cp_cb->fi_y = fi_y[n_elem];
			Cp_cb->Wc = Wc;
			Cp_cb->Wt = Wt;
			Cp_cb->Wx_min = Wx_min;
			Cp_cb->Wy_min = Wy_min;
			memcpy(&(Cp_cb->Sect_Elem), &(Sect_Elem_Group[0]), sizeof(DATA_SECT_SCAD));
			memcpy(&(Cp_cb->param_sect), &(param_sect), sizeof(GEOM_PARAM_SECT));
			memcpy(&(Cp_cb->param_netto), &(param_netto), sizeof(GEOM_PARAM_SECT));
			Cp_cb->fi_e = Fi_e_param.fi_e;
			Cp_cb->fi_b = Fi_y_param.fi_b;
			Cp_cb->fi_y = Fi_y_param.fi_y;   // Fi_y_param.fi_y = fi_y
			Cp_cb->cfi_y = Fi_y_param.fi_y*Fi_y_param.c_;
			Cp_cb->m_ef = Fi_e_param.m_ef;
			//Cp_cb->lambda_b1 = (data_check->step_ext[n_elem]/bef_1)*sqrt(Ry/Ey);
			//Cp_cb->lambda_b2 = (data_check->step_int[n_elem]/bef_2)*sqrt(Ry/Ey);
			Cp_cb->mx = m_x;
			Cp_cb->m_exc = m_exc;
			Cp_cb->Ad = Ad;
			Cp_cb->alfa = alfa_sig;
			Cp_cb->sigma_max = sig_max;
			Cp_cb->tau_max = tau_max;
			Cp_cb->cx_ = cx_;
			Cp_cb->cy_ = cy_;
			Cp_cb->n_ = n_;
		  }
		  if ((ABS(Q_)) > Qmax) {
			Qmax = ABS(Q_);
			Cp->RSU[1][0] = Elem_RSU[i][0];
			Cp->RSU[1][2] = Elem_RSU[i][2];
			Cp->RSU[1][3] = Elem_RSU[i][3];
			Cp->RSU[1][4] = Elem_RSU[i][4];
			Cp->RSU[1][5] = Elem_RSU[i][5];
			Cp->RSU[1][6] = M_c*1e-6;
		  }
		  if ((ABS(M_)) > Mmax) {
			Mmax = ABS(M_);
			NatMmax = N_;
			Mc_at = M_c;
			Cp->nelem = n_elem_rep;
			Cp->hw = h_;
			Cp->hef = hef;
			Cp->RSU[2][0] = Elem_RSU[i][0];
			Cp->RSU[2][2] = Elem_RSU[i][2];
			Cp->RSU[2][3] = Elem_RSU[i][3];
			Cp->RSU[2][4] = Elem_RSU[i][4];
			Cp->RSU[2][5] = Elem_RSU[i][5];
			Cp->RSU[2][6] = M_c*1e-6;
			strcpy(Cp->Steel, MaterProp[Material_Number].title);
			Cp->Ryn = steel_param.Ryn;
			Cp->bef = bef_1;
			Cp->Ry = Ry;
			Cp->Ryw = Ry;
			Cp->Rs = Rs;
			Cp->lambdaX = lambdaX[n_elem];
			Cp->lambdaY = lambdaY[n_elem];
			Cp->lambda_x = lambda_x[n_elem];
			Cp->lambda_y = lambda_y[n_elem];
			Cp->lambda_w = lambda_w;
			Cp->lambda_uw = lambda_uw;
			Cp->lambda_f1 = lambda_f1;
			Cp->lambda_f2 = lambda_f2;
			//Cp->lambdaBF1 = Lambda_f1Y[n_elem];
			//Cp->lambda_bf1 = lambda_f1Y[n_elem];
			//Cp->lambdaBF2 = Lambda_f2Y[n_elem];
			//Cp->lambda_bf2 = lambda_f2Y[n_elem];
			Cp->fi_x = fi_x[n_elem];
			Cp->fi_y = fi_y[n_elem];
			Cp->Wc = Wc;
			Cp->Wt = Wt;
			Cp->Wx_min = Wx_min;
			Cp->Wy_min = Wy_min;
			memcpy(&(Cp->Sect_Elem), &(Sect_Elem_Group[0]), sizeof(DATA_SECT_SCAD));
			memcpy(&(Cp->param_sect), &(param_sect), sizeof(GEOM_PARAM_SECT));
			memcpy(&(Cp->param_netto), &(param_netto), sizeof(GEOM_PARAM_SECT));
			Cp->fi_e = Fi_e_param.fi_e;
			Cp->fi_b = Fi_y_param.fi_b;
			Cp->fi_y = Fi_y_param.fi_y;   // Fi_y_param.fi_y = fi_y
			Cp->cfi_y = Fi_y_param.fi_y*Fi_y_param.c_;
			Cp->m_ef = Fi_e_param.m_ef;
			//Cp->lambda_b1 = (data_check->step_ext[n_elem]/bef_1)*sqrt(Ry/Ey);
			//Cp->lambda_b2 = (data_check->step_int[n_elem]/bef_2)*sqrt(Ry/Ey);
			Cp->mx = m_x;
			Cp->m_exc = m_exc;
			Cp->Ad = Ad;
			Cp->alfa = alfa_sig;
			Cp->sigma_max = sig_max;
			Cp->tau_max = tau_max;
			Cp->cx_ = cx_;
			Cp->cy_ = cy_;
			Cp->n_ = n_;
		  }
		}
		Cp->index_105 = index_105;
		// Конец определения index_105
		//sprintf(stroka,"Mmax = %8.1f кН*м, N=%6.1f кН, mx = %4.1f, m_ef = %4.1f, Mc = %8.1f кН*м", Mmax*1e-6, NatMmax*1e-3, m_x, Fi_e_param.m_ef, Mc_at*1e-6);
		//InfMessage("Сжато-изгибаемый: "+(AnsiString)stroka);

		Mmax = 0;
	  //prinvi("ListElem_RSU", NRSU, ListElem_RSU);

	  //prinm0("Elem_RSU 2", NRSU, 6, Elem_RSU);
//-------------------------------------------------------
// Цикл для остальных критериев
//--------------------------------------------------------
	  for (i = 0; i<NRSU; i++) {
		  n_elem = ListElem_RSU[i];
		  n_elem_rep = n_elem;
		  if (!CheckElem[i][4])
			continue;

		  memcpy((char*) &Sect_Elem_Copy, (char*)&(Sect_Elem_Group[0].com_sect.dvutavr), sizeof(SECT_DVUTAVR));
		  // Установить текущую высоту стенки элемента
		  //Sect_Elem_All[n_elem].com_sect.dvutavr.h = H_sten[n_elem][ListNSect_RSU[i]];

		  //  Вычисление параметров конструктивного элемента по сечению
		  //--------------------------------------------------------------------------
		  // Вычислить геометрические характеристики сечения группы
		  Get_param_sect_comm(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), &param_sect);
		  if (data_check->flag_netto) {
			Get_param_sect_netto(&(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto,
						   data_check->diametr, data_check->num_holes, data_check->space, data_check->step);
		  }
		  else {
			memcpy((char*)&param_netto, (char*)&param_sect, sizeof(GEOM_PARAM_SECT));
		  }
		  i_zz = sqrt(param_sect.Izz/param_sect.Ar);
		  i_yy = sqrt(param_sect.Iyy/param_sect.Ar);
		  // Гибкость элемента
		  lambdaX[n_elem] = data_check->length_XZ[n_elem]/i_zz;
		  lambdaY[n_elem] = data_check->length_YZ[n_elem]/i_yy;
		  // Условная гибкость элемента
		  lambda_x[n_elem] = lambdaX[n_elem]*sqrt(Ry/Ey);     // в плоскости стенки
		  lambda_y[n_elem] = lambdaY[n_elem]*sqrt(Ry/Ey);     // в плоскости поясов

		  Af = MIN(bef_1*tef_1, bef_2*tef_2);   // меньшая площадь пояса
		  Aw = t_*h_;

		  lambda_w = (hef/t_)*sqrt(Ry/Ey);
		  // Условные гибкости свеса поясов
		  lambda_f1 = (((bef_1 - t_)*0.5 - param_sect.Rad)/tef_1)*sqrt(Ry/Ey);
		  lambda_f2 = (((bef_2 - t_)*0.5 - param_sect.Rad)/tef_2)*sqrt(Ry/Ey);
		  // Гибкости поясов в плоскости поясов
		  Lambda_f1Y[n_elem] = (data_check->step_ext[n_elem]*3.4641/bef_1);    // 3.4641 = sqrt(12)
		  Lambda_f2Y[n_elem] = (data_check->step_int[n_elem]*3.4641/bef_2);
		  // Условные гибкости поясов в плоскости поясов
		  lambda_f1Y[n_elem] = Lambda_f1Y[n_elem]*sqrt(Ry/Ey);
		  lambda_f2Y[n_elem] = Lambda_f2Y[n_elem]*sqrt(Ry/Ey);
		  // Вычисление fi_y - коэффициент устойчивости в плоскости поясов при центальном сжатии
		  fi_y[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_y[n_elem]), 3);
		  // Вычисление fi_x коэффициент устойчивости в плоскости стенки при центальном сжатии
		  fi_x[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_x[n_elem]), 3);
		  // коэффициент потери устойчивости при центральном сжатии для поясов
		  //fi_f1 = Round(Fun_fi_713(RECTANCULAR, lambda_f1Y[n_elem]), 3);
		  //fi_f2 = Round(Fun_fi_713(RECTANCULAR, lambda_f2Y[n_elem]), 3);

		  Wx_min = MIN(param_netto.Izz/param_netto.Zct, param_netto.Izz/(param_netto.Hsect - param_netto.Zct));
		  Wy_min = MIN(param_netto.Iyy/param_netto.Yct, param_netto.Iyy/(param_netto.Wsect - param_netto.Yct));
		//}
		N_ = Elem_RSU[i][0]*1000;
		Q_ = Elem_RSU[i][3]*1000;
		M_ = Elem_RSU[i][2]*1e6;
		M_y = Elem_RSU[i][4]*1e6;

		/* Анализ НДС
		if (!CheckTypeNDS(N_, M_, n_elem, chCOMPRESSION_BENDING)) {
		  memcpy((char*)&(Sect_Elem_All[n_elem].com_sect.dvutavr), (char*) &Sect_Elem_Copy, sizeof(SECT_DVUTAVR));
		  continue;
		}
		*/
		if (data_check->M_third > 0.1 && (ABS(Elem_RSU[i][2])) > data_check->M_third)
		  M_c = data_check->M_third*1e6*SIGN(M_);
		else
		  M_c = M_;

	   // for (m=0; m<6; m++) {
	   //   result_check->RSU[j_][k][m] = Elem_RSU[i][m];
	   // }
	   // result_check->RSU[j_][k][m] = M_c*1e-6;

		Forces[0] = Elem_RSU[i][0]*1000;
		Forces[1] = Elem_RSU[i][1]*1e6;
		Forces[2] = Elem_RSU[i][2]*1e6;
		Forces[3] = Elem_RSU[i][3]*1000;
		Forces[4] = Elem_RSU[i][4]*1e6;
		Forces[5] = Elem_RSU[i][5]*1000;

		// Минимальное и максимальное напряжение в стенке
		sig_1 = N_/param_sect.Ar + M_*(param_sect.Zct - tef_1 - param_sect.Rad)/param_sect.Izz;
		sig_2 = N_/param_sect.Ar - M_*(param_sect.Hsect - param_sect.Zct - tef_2 - param_sect.Rad)/param_sect.Izz;
		sig_1w = MIN(sig_1, sig_2);
		sig_2w = MAX(sig_1, sig_2);

		alfa_w = (sig_1w - sig_2w)/sig_1w;
		// Вычисление напряжений
		sigma_beam_comm(&param_sect, Forces, sigma_comm);

		if (sigma_comm[0] < sigma_comm[2])
		  Wc = param_sect.Izz/param_sect.Zct;
		else
		  Wc = param_sect.Izz/(param_sect.Hsect - param_sect.Zct);

		if (N_ != 0) {
		  excentr = ABS(M_/N_);
		  m_exc = excentr*param_sect.Ar/Wc;  // для устойчивости в плоскости момента

		  excentr = ABS(M_c/N_);
		  m_x = excentr*param_sect.Ar/Wc;  // для устойчивости из плоскости момента
		}
		else {
		  m_x = 20;
		  m_exc = 20;
		}

		//if ((ABS(M_*1e-6)) >2761) {
		//   InfMessage("!");
		//}

		// Вычисление fi_e в плоскости действия момента
		Get_fi_e(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_, N_, 0,
				   data_check->length_XZ[n_elem], &param_sect, Ry, Ey, &Fi_e_param);

		// Вычисление fi_b
		double fi_b = Get_fi_b_centr(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_c, N_,
						data_check->length_YZ[n_elem], data_check->step_ext[n_elem], data_check->step_int[n_elem],
						&param_sect, Ry, Ey);

		// Вычисление c_, fi_y для изгибаемых элементов
		Get_c_fi_y(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_c, N_,
					   data_check->length_YZ[n_elem], data_check->step_ext[n_elem], data_check->step_int[n_elem],
					   &param_sect, Ry, Ey, &Fi_y_param, fi_b);

		#ifdef INFMESSAGE_00
		InfMessage("**N_= " + FloatToStr(Round(N_*1e-3, 2)) + "; M_ =" + FloatToStr(Round(M_*1e-6,2)));
		InfMessage("**Fi_y_param.c_ " + FloatToStr(Round(Fi_y_param.c_, 3)) +"; Fi_y_param.fi_y" +
					FloatToStr(Round(Fi_y_param.fi_y, 3)) + "; Fi_e_param.fi_e" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
		#endif

		alfa_x = (ABS(N_))/(Fi_e_param.fi_e*param_sect.Ar*Ry*data_check->gamma_c);
		alfa_y = (ABS(N_))/(Fi_y_param.c_*Fi_y_param.fi_y*param_sect.Ar*Ry*data_check->gamma_c);
		alfa_y0 = (ABS(N_))/(Fi_y_param.fi_y*param_sect.Ar*Ry*data_check->gamma_c);
		lambda_ux = data_check->Limit_lambda1 - data_check->Limit_lambda2*(MAX(0.5, alfa_x));
		lambda_uy = data_check->Limit_lambda1 - data_check->Limit_lambda2*(MAX(0.5, alfa_y0));
		// Вычисление k_x
		if (lambdaX[n_elem]/lambda_ux <= alfa_x || lambdaY[n_elem]/lambda_uy <= alfa_y)
		  k_x = 1.0;
		else {
		  fi_m = MIN(Fi_e_param.fi_e, Fi_y_param.c_*Fi_y_param.fi_y);
		  if ((ABS(N_)) <= 1e-1)
			 k_x = 1.25;
		  else
			 k_x = MIN(sqrt(fi_m*param_sect.Ar*Ry/(ABS(N_))), 1.25);
		}
		// lambda_uw при mx=20 по п. 8.5.8
		lambda_uw20 = Fun_lambda_uw20(M_, Q_, Ry, Ry, Ey, Rs, hef, t_, Af, data_check->gamma_c);
		// Среднее касательное напряжение
		tau_m = (ABS(Q_))/(h_*t_);
		delta_fi = Fi_y_param.c_*Fi_y_param.fi_y - Fi_e_param.fi_e;

		// Предельная условная гибкость стенки по табл. 22
		lambda_uw = Fun_lambda_uw_cent_bend(type_sect, lambda_x[n_elem], m_exc, sig_1w, sig_2w, tau_m, delta_fi,
					Ry, data_check->gamma_c, lambda_uw20);

		#ifdef INFMESSAGE
		InfMessage(IntToStr(i+1)+": N ="+FloatToStr(Round(N_/1000, 1))+", M ="+FloatToStr(Round(M_/1e6, 1)));
		InfMessage("     lambda_uw20 ="+FloatToStr(lambda_uw20)+", lambda_uw ="+FloatToStr(Round(lambda_uw, 3)));
		#endif
		hd = MIN(hef, t_*(lambda_uw - (lambda_w/lambda_uw - 1)*(lambda_uw - 1.2 - 0.15*(MIN(lambda_x[n_elem], 3.5))))*sqrt(Ey/Ry));
		// Редуцированная площадь
		Ad = param_sect.Ar - (hef - hd)*t_;
	//------------------------------------------------------
	// 2. Проверка стенки на действие поперечной силы, п. 8.2.1, ф. (42)
	//    (Прочность стенки по касательным напряжениям)
	//-------------------------------------------------------------------
		if (flag_check[1]) {
		  double krit_1;

		  Qfic = GetQfic(Ey, Ry, N_, fi_x[n_elem]);   // - используется коэффициент fi_x, полученный для центрального сжатия
		  Q_1 = MAX((ABS(Q_)), Qfic);

		  tau_max = Calc_Tau_Pop_Force(N_, M_, Q_1, &(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto, data_check->ugol_var);

		  krit_1 = tau_max/(Rs*data_check->gamma_c);

		  //if (krit_1 > krit[1]) {

		  //  InfMessage("N_elem = "+IntToStr(n_elem+1)+": i_RSU = "+IntToStr(i) + ", N ="+FloatToStr(Round(N_/1000, 1))+
		  //             ", Q_1 ="+FloatToStr(Round(Q_1/1000, 1))+", M ="+FloatToStr(Round(M_/1e6, 1)) +
		  //             ", krit_1 = " + FloatToStr(Round(krit_1, 2)));
		  //  InfMessage("Sx[0] = "+ FloatToStr(Round(param_netto.Sx[0], 0)) +
		  //              ", Izz ="+FloatToStr(Round(param_netto.Izz, 0))+", b ="+FloatToStr(Round(Sect_Elem_All[n_elem].com_sect.dvutavr.b, 0)));
		  //}
		  MAXNNEL(krit[1], krit_1, 1);
		}
		//-------------------------------------------------------------------------------
		// 3. Расчет на прочность стенки при одновременном действии нормальной силы, момента и поперечной силы, п. 8.2.1 ф. (44)
		//---------------------------------------------------------------------------------------
		if (flag_check[2]) {
		  double sig_x1, sig_x2, sig_y1, sig_y2, tau_xy0, tau_xy1, tau_xy2, krit_3;
		 // знак момента: M>0 - внешние волокна сжаты
		  sig_x1 = N_/param_netto.Ar - M_*(param_netto.Zct - tef_1)/param_netto.Izz;
		  sig_x2 = N_/param_netto.Ar + M_*(param_netto.Hsect - param_netto.Zct - tef_2)/param_netto.Izz;
		  switch (data_check->index_local) {
			case 0:
			  sig_y1 = -sigma_loc - data_check->q_ext*1000/(t_);
			  sig_y2 = 0;
			break;
			case 1:
			  sig_y1 = -data_check->q_ext*1000/(t_);
			  sig_y2 = sigma_loc;
			break;
			case 2:
			  sig_y1 = -data_check->q_ext*1000/(t_);
			  sig_y2 = 0;
			break;
		  }
		  //
		  tau_xy0 = (ABS(Q_))*param_netto.Sx[0]/(param_netto.Izz*t_);
		  tau_xy1 = (ABS(Q_))*param_netto.Sx[1]/(param_netto.Izz*t_);
		  tau_xy2 = (ABS(Q_))*param_netto.Sx[2]/(param_netto.Izz*t_);
		  krit_2 = MAX(0.87*sqrt(sig_x1*sig_x1 - sig_x1*sig_y1 + sig_y1*sig_y1 + 3*tau_xy1*tau_xy1)/(Ry*data_check->gamma_c),
					   0.87*sqrt(sig_x2*sig_x2 - sig_x2*sig_y2 + sig_y2*sig_y2 + 3*tau_xy2*tau_xy2)/(Ry*data_check->gamma_c));
		  krit_2 = MAX(krit_2, tau_xy0/(Rs*data_check->gamma_c));
		  MAXNNEL(krit[2], krit_2, 2);
		}
		//--------------------------------------------------------------------
		// 4. Расчет на прочность растянутого волокна, п. 9.1.3, ф.(107)
		//-----------------------------------------------------------------
		if (flag_check[3]) {
		  double Wm, delta;
		  if (steel_param.Ryn > 440) {
			if (M_ < 0)   // знак момента: M>0 - внешние волокна сжаты
			  Wm = param_netto.Izz/param_netto.Zct;
			else
			  Wm = param_netto.Izz/(param_netto.Hsect - param_netto.Zct);
			delta = 1 - 0.1*(ABS(N_))*lambda_x[n_elem]*lambda_x[n_elem]/(param_sect.Ar*Ry);
			MAXNNEL(krit[3], (data_check->koeff_material_nadeghn/(Ru*data_check->gamma_c))*
					   (ABS(N_/param_netto.Ar + (ABS(M_))))/(delta*Wm), 3);
		  }
		}
		//------------------------------------------------------------------------------------------------------
		// 5. Расчет на устойчивость из плоскости стенки (YZ) по стержневой аналогии для сжатого пояса, п. 7.1.3, ф. (7)
		//----------------------------------------------------------------------------
		double sig_x1f, sig_x2f;
		  // Напряжения в ц.т. поясов
		  sig_x1f = N_/param_netto.Ar - M_*(param_netto.Zp)/param_netto.Izz;
          sig_x2f = N_/param_netto.Ar + M_*(param_netto.Hp - param_netto.Zp)/param_netto.Izz;
			if (sig_x1f < 0) {
			  sig_x1f -= ABS(M_y/Wy_min);
            }
            else {
			  sig_x1f += ABS(M_y/Wy_min);
            }
			//tau_xy1 = (ABS(Q_y))*Sy/(Iyy*t_y);
			if (sig_x2f < 0) {
			  sig_x2f -= ABS(M_y/Wy_min);
            }
            else {
			  sig_x2f += ABS(M_y/Wy_min);
            }
			//tau_xy2 = (ABS(Q_y))*Sy/(Iyy*t_y);
		  Af1 = bef_1*tef_1;
		  Nf1 = Af1*sig_x1f;
          Af2 = bef_2*tef_2;
          Nf2 = Af2*sig_x2f;

		if (flag_check[4]) {
		   COMMON_SECT sect_f;
		   GEOM_PARAM_SECT param_sect_f;
		   FI_E_PARAM Fi_e_param_f;
		   double length_f, Nf;

		   double krit_4;
		   double lambda_f = lambda_f1Y[n_elem];
		   double fi_f = Round(Fun_fi_713(RECTANCULAR, lambda_f), 2);

		   sect_f.rect_solid.h = bef_1;
		   sect_f.rect_solid.b = tef_1;
		   length_f = data_check->step_ext[n_elem];
		   Af = Af1;
		   Nf = MIN(Nf1, Nf2);
		   if (Nf < 0) {
			 if ((ABS(M_y)) <1000) {    // центрально сжатый
			  krit_4 = -Nf/(fi_f*Af*Ry*data_check->gamma_c);
			 }
			 else {
			  Get_param_sect_comm(RECTANCULAR, &(sect_f), &param_sect_f);
			  // вид потери устойчивости и тип сечения прямоугольник
			  Get_fi_e(RECTANCULAR, &(sect_f), M_y, Nf, 0, length_f, &param_sect_f, Ry, Ey, &Fi_e_param_f);
			  krit_4 = -Nf/(Fi_e_param_f.fi_e*Af*Ry*data_check->gamma_c);
			 }
			 MAXNNEL(krit[4], krit_4, 4);
		}
		// 6. Необходимость укрепления стенки поперечными ребрами жесткости п. 7.3.3.
		if (flag_check[5] ) {
			MAXNNEL(krit[5],lambda_w/2.3, 5);
		}
	   //-----------------------------------------------------------
	   // 7. Проверка устойчивости стенки, п. 8.5.1, 8.5.3, 8.5.6, 8.5.7, 8.5.8 или по интегральному критерию для переменной высоты стенки
	   //-----------------------------------------------------------
		if (flag_check[6]) {
		   double M1, M2;
		   double a_otsek;

		   if (index_105==0) {  // формула 106 - пластика не допускается
			 if (data_check->edge_step <10.0) {
			   double k12;
			   if (sigma_loc < 1.0 ) {
				 //if (data_check->index_nf >0 || Sect_Elem_Group[ngroup].com_sect.dvutavr.n_group >=0)
				 if (Sect_Elem_Group[ngroup].com_sect.dvutavr.n_group >=0)
					k12 = 3.5;
				 else
					k12 = 3.2;
			   }
			   else
				 k12=2.5;
			   krit_6 = lambda_w/k12;
			#ifdef EMBRAC
				 rc = Application->MessageBox(L"Для выполнения проверки устойчивости стенки необходимо задать шаг ребер",L"Изгибаемые элементы",
				   MB_OK | MB_ICONWARNING);
			#else
				 rc = Application->MessageBox("Для выполнения проверки устойчивости стенки необходимо задать шаг ребер","Изгибаемые элементы",
				   MB_OK | MB_ICONWARNING);
			#endif
			   }
			 }
			 else {
			   a_otsek = data_check->edge_step;
		   //M1 = M_ - Q_*a_otsek/2;
		   //M2 = M_ + Q_*a_otsek/2;
			   M1 = M_;
			   M2 = M_;

			  krit_6 = CheckStab_norm(&(Sect_Elem_Group[0].com_sect.dvutavr), &(Sect_Elem_Group[0].com_sect.dvutavr),
									 sigma_loc, data_check->length_XZ[n_elem],
									 M1, M2, Q_, N_, Ry, Rs, Ey, a_otsek, data_check->index_place_local, data_check->gamma_c);

			 }
		   }
		   else {  // Формула 105
			 // Условие п. 8.5.8
			 double tau_m, alfa, sig1, sig2, A1, A2, h1, Dev;

			 tau_m = (ABS(Q_))/(t_*h_);
			 alfa = Fun_alfa_18(lambda_w, tau_m/Rs);

			 if (bef_1 == bef_2 && tef_1 == tef_2) {
			  // симметричное сечение
			   krit_6 = (ABS(M_))/(Ry*data_check->gamma_c*hef*hef*t_*(bef_1*tef_1/(h_*t_) + alfa));
			 }
			 else { // моносимметричное сечение
			   if (sigma_comm[0]<0) {
				 sig1 = MIN((ABS(sigma_comm[0])), Ry);
				 sig2 = MIN((ABS(sigma_comm[2])), Ry);
				 A1 = bef_1*tef_1;
				 A2 = bef_2*tef_2;
			   }
			   if (sigma_comm[2]<0) {
				 sig1 = MIN((ABS(sigma_comm[2])), Ry);
				 sig2 = MIN((ABS(sigma_comm[0])), Ry);
				 A1 = bef_2*tef_2;
				 A2 = bef_1*tef_1;
			   }
			  //t и tw в формуле 87 равны
			   h1 = h_*t_/(2*t_)+(A2*sig2 - A1*sig1)/(2*t_*sqrt(Ry*Ry-3*tau_m*tau_m));
			   Dev = sig1*A1*h1 + sig2*A2*(h_ - h1)+4*h1*h1*t_*alfa*Ry +
					 h_*t_*(h_ - 2*h1)*sqrt(Ry*Ry-3*tau_m*tau_m)*0.5;
			   krit_6 = (ABS(M_))/(Dev*data_check->gamma_c);
			 }
		   }
		   MAXNNEL(krit[6], krit_6, 6);
		}
		//--------------------------------------------------
		// 8. Проверка местной устойчивости пояса, п. 9.4.7.
		//-------------------------------------------------
		if (flag_check[7]) {
		  double lambda_uf1, lambda_uf20, sig_f1;
		  if (sigma_comm[0] < 0) {
			  // Вычисление lambda_uf20
			  sig_f1 = ABS(N_/param_netto.Ar - M_*(param_netto.Zp)/param_netto.Izz);
			  // Функция вычисления предельной гибкости поясов при mx = 20 по п. 8.5.18 или 8.5.19 СП
			  lambda_uf20 = Fun_lambda_uf20(index_105, Ry, sig_f1, lambda_uw20);
			  // Функция вычисления предельной гибкости поясов по табл. 23 СП - при внецентренном сжатии
			  lambda_uf1 = Fun_lambda_uf_cent_bend(Sect_Elem_Group[0].type_sect, lambda_cent, lambda_x[n_elem], lambda_uf20, m_x, Ry);

		#ifdef INFMESSAGE
		InfMessage("lambda_f1 = "+FloatToStr(Round(lambda_f1, 3))+", lambda_uf1 = "+FloatToStr(Round(lambda_uf1, 3)));
		InfMessage("krit_16 = "+FloatToStr(Round(lambda_f1/(k_x*lambda_uf1), 3)));
		#endif
			  MAXNNEL(krit[7], lambda_f1/(k_x*lambda_uf1), 7);
		  }
		  else
			krit[7] = MAX(krit[7], -1);
		}
		//-----------------------------------------------------------------
		// 9. Проверка предельной гибкости в плоскости поясов, табл. 33
		//-----------------------------------------------------------------
        k_ = 1;
		if (flag_check[8]) {
		  MAXNNEL(krit[8], lambdaY[n_elem]/(k_*lambda_uy), 8);
		}
		if (flag_check[8]) {
		//-----------------------------------------------------------------
		// 10. Проверка предельной гибкости в плоскости стенки, табл. 32
		//-----------------------------------------------------------------
		  MAXNNEL(krit[9], lambdaX[n_elem]/(k_*lambda_ux), 9);
		}
		for (int j=0; j<10; j++) {
		  if (krit[j] > krit_max) {
			krit_max = krit[j];
			RSU_max = n_elem;
		  }
		}
	  }

	  n_elem = ListElem_RSU[RSU_max];
		  memcpy((char*)&(Cp->param_sect), (char*)&(param_sect), sizeof(GEOM_PARAM_SECT));
		  memcpy((char*)&(Cp->param_netto), (char*)&(param_netto), sizeof(GEOM_PARAM_SECT));
		  memcpy((char*)&(Cp->Sect_Elem), (char*)&(Sect_Elem_Group[0]), sizeof(DATA_SECT_SCAD));
		  Cp->RSU[0][0] = Elem_RSU[RSU_max][0];
		  Cp->num_elem[0] = n_elem;
		  strcpy(Cp->Steel, MaterProp[Material_Number].title);
		  Cp->Ryn = steel_param.Ryn;
		  Cp->hsect = h_;
		  Cp->bsect = b_;
		  Cp->bef = bef_1;
		  Cp->hef = hef;
		  Cp->Ry = Ry;
		  //Cp->Ryw = Ryw;
		  //Cp->Rs = Rsw;
		  Cp->Ryw = Ry;
		  Cp->Rs = Rs;
		  Cp->lambdaX = lambdaX[n_elem];
		  Cp->lambdaY = lambdaY[n_elem];
		  Cp->lambda_x = lambda_x[n_elem];
		  Cp->lambda_y = lambda_y[n_elem];
		  Cp->lambda_w = lambda_w;
		  Cp->lambda_uw = lambda_uw_[n_elem];
		  Cp->lambda_f = lambda_f;
		  Cp->lambda_uf = lambda_uf_[n_elem];
		  Cp->lambda_f1 = lambda_f1;
		  Cp->lambda_f2 = lambda_f2;
		  Cp->fi_x = fi_x[n_elem];
		  Cp->fi_y = fi_y[n_elem];
		  Cp->Ad = Ad_[n_elem];
	  memcpy((char*)&Data_check_U, (char*)data_check, sizeof(DATA_CHECK_U));

   }









