//#define INFMESSAGE_0 false
   //--------------------------------------------------------------------------
   // Внецентренно-сжатые с плоской стенкой постоянной высоты , табл. 2.2.6 ТЗ
   // Внецентренно-сжатые с плоской стенкой переменной высоты , табл. 2.2.7 ТЗ
   //#define  INFMESSAGE_1
   //#define  DEBUG
   //---------------------------------------------------------------------------
   //  length_XZ - расчетная длина в плоскости стенки
   //  length_YZ - расчетная длина в плоскости поясов
   //  lambdaX - гибкость элемента элемента в плоскости стенки
   //  lambda_x  - условная гибкость элемента элемента в плоскости стенки
   //  lambdaY - гибкость элемента элемента в плоскости поясов
   //  lambda_y - условная гибкость элемента элемента в плоскости поясов
   //---------------------------------------------------------------------------
   if (data_check->index_type == COMPRESSION_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 alfa_sig;   // (sig1-sig2)/sig1;
	  double Q_1, tau_max, sig_max;
	  bool flag_Ad;
	  double krit_51c, krit_5;
	  int index_flex_1_const;
	  double lambda_uw_m;

	  double krit_comp_max = 0;
	  int RSU_comp_max;



	  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 Nmin = 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->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)));
	  // Ry = 250;
	  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][2])
			continue;

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

		  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);     // в плоскости поясов

		  h_ = Sect_Elem_Group[0].com_sect.dvutavr.h;
		  hef = h_ - 2*param_sect.Rad;

		  t_ = Sect_Elem_Group[0].com_sect.dvutavr.b;
		  bef_1 = Sect_Elem_Group[0].com_sect.dvutavr.b1;
		  tef_1 = Sect_Elem_Group[0].com_sect.dvutavr.h1;
		  bef_2 = Sect_Elem_Group[0].com_sect.dvutavr.b2;
		  tef_2 = Sect_Elem_Group[0].com_sect.dvutavr.h2;
		  Af = MIN(bef_1*tef_1, bef_2*tef_2);   // меньшая площадь пояса
		  Aw = t_*h_;

		  lambda_w = (hef/t_)*sqrt(Ryw/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], 1), 3);
		  // Вычисление fi_x коэффициент устойчивости в плоскости стенки при центальном сжатии
		  fi_x[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_x[n_elem], 0), 3);
		  //InfMessage("fi_x="+FloatToStr(fi_x)+"lambda_x="+FloatToStr(lambda_x));
		  // коэффициент потери устойчивости при центральном сжатии для поясов
		  fi_f1 = Round(Fun_fi_713(RECTANCULAR, lambda_f1Y[n_elem], 0), 3);
		  fi_f2 = Round(Fun_fi_713(RECTANCULAR, lambda_f2Y[n_elem], 0), 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 (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_;

		/* Анализ НДС
		  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;
		  }
		*/
	   // sprintf(stroka,"M_=%8.1f", Elem_RSU[i][2]);
	   // InfMessage("Comp-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, Ryw, Ey, Rsw, 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.6), (2.2.7) ------------------------------------------------------
          // Расчет на прочность по нормальным напряжениям, п. 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, r_, A1, A2, h1, Dev;

              tau_m = (ABS(Q_))/(t_*h_);
              r_ =  MAX(1.0, Ry/Ryw);
              alfa = Fun_alfa_18(lambda_w, tau_m/Rsw);

			  if (bef_1 == bef_2 && tef_1 == tef_2) {
                // симметричное сечение
				krit_8_5_8 = (ABS(M_))/(Ry*data_check->gamma_c*hef*hef*t_*(r_*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(Ryw*Ryw-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(Ryw*Ryw-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_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*Rsw && !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*Rsw && !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;
				Cp->n_pow = n_;
				Cp->beta = beta;
				Cp->cx = cx_;
				Cp->cy = cy_;
				Cp->N_105 = ABS(N_);
			  }
			  // 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)));
   			  if (sig_sum > (ABS(sig_int + sig_M_y))) {
				 Cp->y_106 = param_sect.Zct;
			  }
			  else {
				 Cp->y_106 = (param_sect.Hsect - param_sect.Zct);
			  }
			  Cp->x_106 = param_netto.Iyy/Wy_min;


			  krit_106 = sig_sum/(Ry*data_check->gamma_c);
			  if (krit[0] < krit_106) {
				krit[0] = krit_106;
				nnel_krit[0] = n_elem_rep;
				Cp->N_ = ABS(N_);
			  }
			  //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_, &(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto, data_check->ugol_var);
          if (N_ < Nmin) {

			Nmin = 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_sect;
			Cp->bsect = b_sect;

            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_;
			Cp->A_netto = param_netto.Ar;
		}
          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_;

			Cp->Mx = M_;
			Cp->My = M_y;
			Cp->Qy = Q_;
			Cp->Qx = Q_y;
			Cp->N_ = 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, MaterPropU_prof.title);
			Cp->Ryn = steel_param.Ryn;
			Cp->bef = bef_1;
			Cp->Ry = Ry;
			Cp->Ryw = Ryw;
			Cp->Rs = Rsw;
			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);
	  double  step_edge = 1e6;

	  for (i = 0; i<NRSU; i++) {
		  n_elem = ListElem_RSU[i];
		  n_elem_rep = n_elem;
		  if (!CheckElem[i][2])
			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);     // в плоскости поясов

		  h_ = Sect_Elem_Group[0].com_sect.dvutavr.h;
		  hef = h_ - 2*param_sect.Rad;

		  t_ = Sect_Elem_Group[0].com_sect.dvutavr.b;
		  bef_1 = Sect_Elem_Group[0].com_sect.dvutavr.b1;
		  tef_1 = Sect_Elem_Group[0].com_sect.dvutavr.h1;
		  bef_2 = Sect_Elem_Group[0].com_sect.dvutavr.b2;
		  tef_2 = Sect_Elem_Group[0].com_sect.dvutavr.h2;
		  Af = MIN(bef_1*tef_1, bef_2*tef_2);   // меньшая площадь пояса
		  Aw = t_*h_;

		  lambda_w = (hef/t_)*sqrt(Ryw/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], 1), 3);
		  // Вычисление fi_x коэффициент устойчивости в плоскости стенки при центальном сжатии
		  fi_x[n_elem] = Round(Fun_fi_713(Sect_Elem_Group[0].type_sect, lambda_x[n_elem], 0), 3);
		  // коэффициент потери устойчивости при центральном сжатии для поясов
		  fi_f1 = Round(Fun_fi_713(RECTANCULAR, lambda_f1Y[n_elem], 0), 3);
		  fi_f2 = Round(Fun_fi_713(RECTANCULAR, lambda_f2Y[n_elem], 0), 3);

		  Wx_min = MIN(param_netto.Izz/param_netto.Zct, param_netto.Izz/(param_netto.Hsect - param_netto.Zct));
		  Wy_min = MIN(2*param_netto.Iyy/bef_1, 2*param_netto.Iyy/bef_2);
		//}
		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, Ryw, Ey, Rsw, 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_, &(Sect_Elem_Group[0].com_sect.dvutavr), &param_netto, data_check->ugol_var);

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

		  if (krit_1 > krit[1]) {
			Cp->Sx = param_netto.Sx[0];
			Cp->Iy = param_sect.Iyy;
			Cp->Ix = param_sect.Izz;
			Cp->tw = Sect_Elem_Group[0].com_sect.dvutavr.b;
			Cp->tf = Sect_Elem_Group[0].com_sect.dvutavr.h1;

		  //  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);
		}
		if (flag_check[2]) {  // Не выполняется
		// 3. Расчет на прочность стенки не укрепленной ребрами жесткости, при действии местного напряжения,
		//    а также в опорных сечениях, п. 8.2.2, ф. (46)
		   if (krit[2] < sigma_loc/(Ryw*data_check->gamma_c)) {
			 krit[2] = sigma_loc/(Ryw*data_check->gamma_c);
			 nnel_krit[2] = n_elem_rep;
		   }
		}
		// Прочность стенки по эквивалентным напряжениям п. 8.2.1 ф. (44)
		if (flag_check[3]) {
		// 4. Расчет на прочность стенки при одновременном действии нормальной силы, момента и поперечной силы, п. 8.2.1 ф. (44)
		  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_3 = MAX(0.87*sqrt(sig_x1*sig_x1 - sig_x1*sig_y1 + sig_y1*sig_y1 + 3*tau_xy1*tau_xy1)/(Ryw*data_check->gamma_c),
					   0.87*sqrt(sig_x2*sig_x2 - sig_x2*sig_y2 + sig_y2*sig_y2 + 3*tau_xy2*tau_xy2)/(Ryw*data_check->gamma_c));
		  krit_3 = MAX(krit_3, tau_xy0/(Rsw*data_check->gamma_c));
		  if (krit_3 > krit[3]) {
			if (sqrt(sig_x1*sig_x1 - sig_x1*sig_y1 + sig_y1*sig_y1 + 3*tau_xy1*tau_xy1) >
				sqrt(sig_x2*sig_x2 - sig_x2*sig_y2 + sig_y2*sig_y2 + 3*tau_xy2*tau_xy2)) {
				Cp->sig_xw = Round(sig_x1, 2);
				Cp->sig_yw = Round(sig_y1, 2);
				Cp->tau_w = Round(tau_xy1, 2);
			}
			else {
				Cp->sig_xw = Round(sig_x2, 2);
				Cp->sig_yw = Round(sig_y2, 2);
				Cp->tau_w = Round(tau_xy2, 2);
			}
		  }
		  MAXNNEL(krit[3], krit_3, 3);
		}
		// 5. Прочность растянутого волокна, п. 9.1.3, ф.(107)
		if (flag_check[4]) {
		  double Wtn, delta4;
		  if (steel_param.Ryn > 440) {
			if (M_ < 0)   // знак момента: M>0 - внешние волокна сжаты
			  Wtn = Round(param_netto.Izz/param_netto.Zct, 0);
			else
			  Wtn = Round(param_netto.Izz/(param_netto.Hsect - param_netto.Zct), 0);
			delta4 = Round(1 - 0.1*(ABS(N_))*lambda_x[n_elem]*lambda_x[n_elem]/(param_sect.Ar*Ry), 3);
			double krit_4 = (data_check->koeff_material_nadeghn/(Ru*data_check->gamma_c))*
							(ABS(N_/param_netto.Ar + (ABS(M_))))/(delta4*Wtn);
			if (krit_4 > krit[4]) {
			   Cp->gamma_u = data_check->koeff_material_nadeghn;
			   Cp->Ru = Ru;
			   Cp->delta4 = delta4;
			   Cp->Wtn = Wtn;
			}
			MAXNNEL(krit[4], krit_4, 4);
		  }
		}
		// В сответствии с п. 10.4.2
		if ((data_check->index_otvetstv == 0 || data_check->index_otvetstv == 1) &&
			   data_check->index_group <= 3)
			k_ = 1;
		else
			k_ = 1.1;
		Cp->k_ = k_;

		Cp->k_y = 1;  // k_y здесь не  применяется

		// 6. Расчет на устойчивость в плоскости стенки (XZ), п. 9.2.1 ф.(109)
		// (для постоянного сечения (плоская форма)
		if (flag_check[5]) {  // для !flag_const расчет выполняется после [6] и [7]
		  // Последняя правка 27.09.2018
		  Ar = param_sect.Ar;
		  if (lambda_w > k_x*lambda_uw && data_check->flag_compress_gib) {
			if (Fi_y_param.c_*Fi_y_param.fi_y > Fi_e_param.fi_e)
			  Ar = Ad;
			else {
			  if (alfa_w <= 0.5)
				Ar = Ad;
			}
		  }
		  fi_e[n_elem] = Fi_e_param.fi_e;

		  krit_51c = (ABS(N_))/(fi_e[n_elem]*Ar*Ry*data_check->gamma_c);

		  if (krit[5] < krit_51c) {
			 N_at5 = N_;
			 fy_at5 = Fi_y_param.fi_y;
			 c_at5 = Fi_y_param.c_;
			 fe_at5 = Fi_e_param.fi_e;
			 M_at5 = M_;
			 Ar_at5 = Ar;
			 lambda_uw_at5 = lambda_uw;
			 if (Ar==Ad)  // Необходимо для п. 14 - стенка постоянной высоты
			   flag_Ad = true;
			 else
			   flag_Ad = false;
			 if (krit_51c > krit[5]) {
			   Cp->fi_e = fi_e[n_elem];
			   Cp->Ar = Ar;
             }
			 MAXNNEL(krit[5], krit_51c, 5);
		#ifdef INFMESSAGE
			 sprintf(stroka,"n_elem=%d, krit_5=%5.2f, M=%8.1f кН*м, N=%6.1f кН, fi_e=%5.2f, Ar=%6.0f, Ared=%6.0f, Ry=%6.0f, gamma_c=%6.2f",
					  n_elem, krit_51c, M_*1e-6, N_*1e-3, fe_at5, Ar_at5, Ad, Ry, data_check->gamma_c);
			 InfMessage("Устойчивость в плоскости: "+(AnsiString)stroka);
			 sprintf(stroka,"lambda_w=%5.2f, lambda_uw=%5.2f, k_x=%6.0f, k_x*lambda_uw=%5.2f && c=%5.2f, fi_y=%5.2f, c*fi_y=%5.2f, fi_e=%5.2f",
					  lambda_w, lambda_uw, k_x, k_x*lambda_uw, Fi_y_param.c_, Fi_y_param.fi_y, Fi_y_param.c_*Fi_y_param.fi_y, Fi_e_param.fi_e);
			 InfMessage((AnsiString)stroka);
		#endif
		  }
		}

		// 7. Устойчивость в плоскости поясов (YZ), п. 9.2.3 ф.(111)
		// (из плоскости стенки) постоянного сечения (изгибно-крутильная форма)
		if (flag_check[6]) {
		  double krit_56c, krit_5;
		  Ar = param_sect.Ar;
		  if (alfa_w <= 0.5 && lambda_w > k_x*lambda_uw &&
			  data_check->flag_compress_gib) {
			Ar = Ad;
		  }
		  krit_56c = (ABS(N_))/(Fi_y_param.c_*Fi_y_param.fi_y*Ar*Ry*data_check->gamma_c);

		  if (krit[6] < krit_56c ) {
			 N_at6 = N_;
			 c_at6 = Fi_y_param.c_;
			 fy_at6 = Fi_y_param.fi_y;
			 Mc_at6 = M_c;
			 M_at6 = M_;
			 Ar_at6 = Ar;
			 Cp->c_ = Fi_y_param.c_;
			 Cp->fi_y = Fi_y_param.fi_y;
			 MAXNNEL(krit[6], krit_56c, 6);
		  }
		}
		//-----------------------------------------------
		// 8 (9) Устойчивость при изгибе в двух плоскостях п. 9.2.9, ф.(116)
		fi_ey[n_elem] = 0;
		fi_exy[n_elem] = 0;
		if (flag_check[7] && (ABS(M_y)) > 1.0) {

		  Get_fi_e(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_y, N_, 1,
				   data_check->length_YZ[n_elem], &param_sect, Ry, Ey, &Fi_e_param);
		  fi_ey[n_elem] = Fi_e_param.fi_e;

		  Get_c_fi_y(Sect_Elem_Group[0].type_sect, &(Sect_Elem_Group[0].com_sect), M_, N_,
					   data_check->length_XZ[n_elem],  data_check->step_ext[n_elem], data_check->step_int[n_elem],
					   &param_sect, Ry, Ey, &Fi_y_param, fi_b);
		  fi_exy[n_elem] = fi_ey[n_elem]*(0.6*pow(Fi_y_param.c_, 0.33333) + 0.4*pow(Fi_y_param.c_, 0.25));

		  //sprintf(stroka,"c=%5.3f, fi_exy=%5.3f",
		  //			  Fi_y_param.c_, fi_exy[n_elem]);
		  //InfMessage((AnsiString)stroka);

		  Ar = param_sect.Ar;
		  if (lambda_w > k_x*lambda_uw && data_check->flag_compress_gib) {
			if (Fi_y_param.c_*Fi_y_param.fi_y > Fi_e_param.fi_e)
			  Ar = Ad;
			else {
			  if (alfa_w <= 0.5)
				Ar = Ad;
			}
		  }
		  double krit_7 = (ABS(N_))/(fi_exy[n_elem]*Ar*Ry*data_check->gamma_c);
		  if (krit_7 > krit[7]) {
			  Cp->fi_exy = fi_exy[n_elem];
			  Cp->fi_ey = fi_ey[n_elem];
		  }
		  MAXNNEL(krit[7], krit_7, 7);
		}
		Cp->a_step = data_check->edge_step;
		Cp->hef = hef;
		// 9 (10) Необходимость укрепления стенки поперечными ребрами жесткости п. 7.3.3.
		if (flag_check[8] ) {
		  if (!data_check->flag_step_edge) {
			if (lambda_w >= 2.3 || krit[5]>1.0) {
				int n_edge;
				n_edge = ceil(data_check->length[n_elem]/(3*hef));
				data_check->edge_step = step_edge = MIN(step_edge, Round(floor(data_check->length[n_elem]/n_edge), -2));
				MAXNNEL(krit[8], 1.0, 8);
			}
			else {
				MAXNNEL(krit[8], -1.0, 8);
			}
		  }
		  else {
			if (lambda_w >= 2.3) {
			   MAXNNEL(krit[8], data_check->edge_step/(3*hef), 8);
			}
			else {
				MAXNNEL(krit[8], -1.0, 8);
			}
		  }
		}
		if (flag_check[9] && data_check->flag_step_edge && lambda_w/2.3 > 1.0) {   // Не активна
		// 10. Проверка шага поперечных ребер, п. 7.3.3
		  //if (krit[8+inc] > 1) {
		  if (data_check->edge_step <1.0) {
			  rc = Application->MessageBox(L"Для выполнения проверки шага поперечных ребер необходимо задать величину шага",L"Сжато-изгибаемые элементы",
				 MB_OK | MB_ICONERROR);
			  return rc;
		  }
		  MAXNNEL(krit[9], data_check->edge_step/(3*hef), 9);
		  //}
		}

		if (flag_check[10]) {
		// 11. Проверка ширины поперечных ребер, п. 7.3.3
		  if (data_check->edge_width == 0) {
			#ifdef EMBRAC
			rc = Application->MessageBox(L"Для выполнения проверки ширины поперечных ребер необходимо задать ширину ребер",L"Сжато-изгибаемые элементы",
				 MB_OK | MB_ICONERROR);
			#else
			rc = Application->MessageBox("Для выполнения проверки ширины поперечных ребер необходимо задать ширину ребер","Сжато-изгибаемые элементы",
				 MB_OK | MB_ICONERROR);
			#endif
			 return rc;
		  }
		  if (data_check->type_edge == 0) {
			MAXNNEL(krit[10], (h_/20 + 50)/data_check->edge_width, 10);
		  }
		  else
			MAXNNEL(krit[10], (h_/30 + 40)/data_check->edge_width, 10);
		}
		if (flag_check[11]) {
		// 12. Проверка толщины поперечных ребер, п. 7.3.3
		  if (data_check->edge_thick == 0) {
			#ifdef EMBRAC
			 rc = Application->MessageBox(L"Для выполнения проверки толщины поперечных ребер необходимо задать толщину ребер",L"Сжато-изгибаемые элементы",
				 MB_OK | MB_ICONERROR);
			#else
			 rc = Application->MessageBox("Для выполнения проверки толщины поперечных ребер необходимо задать толщину ребер","Сжато-изгибаемые элементы",
				 MB_OK | MB_ICONERROR);
			#endif
			return rc;
		  }
		  MAXNNEL(krit[11], 2*data_check->edge_width*sqrt(Ry/Ey)/data_check->edge_thick, 11);
		}
		// 13. Проверка устойчивости поперечных ребер жесткости в местах приложения сосредоточенных сил, п. 8.5.10.
		if (flag_check[12] && data_check->Local_F_ != 0.0) {
          double Ar, Izz, i_zz, lambda_, fi_;
          double krit_51;
		  COMMON_SECT sect_edge;
          GEOM_PARAM_SECT param_sect_edge;
          FI_E_PARAM Fi_e_param_e;

          if (data_check->index_local == 0) {  // нагрузка приложена к внешнему поясу
            Ar = (data_check->edge_thick*data_check->edge_width)*(data_check->type_edge + 1) + 2*0.65*t_*t_*sqrt(Ey/Ry);
            Izz = (data_check->type_edge + 1)*pow(data_check->edge_thick, 3)*data_check->edge_width/12 +
                pow(0.65*t_*sqrt(Ey/Ry), 3)*t_/12;
			i_zz = sqrt(Izz/Ar);
            lambda_ = sqrt(Ry/Ey)*h_/i_zz;
			sect_edge.dvutavr.h1 = t_;
            sect_edge.dvutavr.b1 = 2*0.65*t_*t_*sqrt(Ey/Ry);
            sect_edge.dvutavr.h = data_check->edge_width;
            sect_edge.dvutavr.b =data_check->edge_thick;
            sect_edge.dvutavr.n_group = -1;

            if (data_check->type_edge==0) { // одностороннее ребро
			  sect_edge.dvutavr.h2 = 0;
              sect_edge.dvutavr.b2 = 0;

              Get_param_sect_comm(DVUTAVR, &(sect_edge), &param_sect_edge);
            // вид потери устойчивости и тип сечения TAVR или прямоугольник
            // Внецентренно-сжатый элемент, устойчивость из плоскости действия момента
              Get_fi_e(TAVR_UP, &(sect_edge), data_check->Local_F_*(data_check->edge_width + t_)/2, data_check->Local_F_, 0,
                       h_, &param_sect_edge, Ry, Ey, &Fi_e_param_e);
			  MAXNNEL(krit[12], data_check->Local_F_/(Fi_e_param_e.fi_e*Ar*Ry*data_check->gamma_c), 12);
			}
            else {    // парное ребро
              sect_edge.dvutavr.h2 = t_;
              sect_edge.dvutavr.b2 = 2*0.65*t_*t_*sqrt(Ey/Ry);
             // Центрально-сжатый элемент
             // Коэффициент устойчивости при центральном сжатии
			  fi_ = Fun_fi_713(RECTANCULAR, lambda_, 0);
              MAXNNEL(krit[12], data_check->Local_F_/(fi_*Ar*Ry*data_check->gamma_c), 12);
			}
          }
		}
        // 14. Проверка устойчивости стенки постоянной высоты, если с*fi_y > fi_e
		if (flag_check[13]) {
		  //   Проверка предельной гибкости стенки при с*fi_y > fi_e
		  //     (устойчивость из плоскости менее критична чем устойчивость в плоскости)
		  if (Fi_y_param.c_*Fi_y_param.fi_y > Fi_e_param.fi_e )  {
			if (krit_51c <= 1.0 && krit_51c >= 0.8) {  // п. 9.4.3 - увеличение предельной условной гибкости
			  lambda_uw_m = lambda_uw1 + 5*(lambda_uw2 - lambda_uw1)*(1.0 - krit_51c);
			}
			else {
			  if (krit_51c < 0.8)
				 lambda_uw_m = lambda_uw2;
			  else
				 lambda_uw_m = lambda_uw;
			}
		   #ifdef INFMESSAGE_0
			if (krit[13] < lambda_w/(k_x*lambda_uw_m)) {
			  InfMessage(" Постоянная высота стенки с*fi_y > f_e");
			  InfMessage("N_= " + FloatToStr(Round(N_*1e-3, 2)) + "; M_ =" + FloatToStr(Round(M_*1e-6,2)));
			  InfMessage("c_ " + FloatToStr(Round(Fi_y_param.c_, 3)) +"; fi_y =" +
					FloatToStr(Round(Fi_y_param.fi_y, 3)) + "; fi_e =" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
			  InfMessage("c_*fi_y=" + FloatToStr(Round(Fi_y_param.c_*Fi_y_param.fi_y, 3))+"; fi_e =" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
			  InfMessage("lambda_w = "+FloatToStr(Round(lambda_w, 3)));
			  InfMessage("k_x = "+FloatToStr(Round(k_x, 3)));
			  InfMessage("lambda_uw = "+FloatToStr(Round(lambda_uw_m, 3)));
			  InfMessage("krit_14 = "+FloatToStr(Round(lambda_w/(k_x*lambda_uw_m), 3)));
			}
		   #endif
			if (m_exc > 5 && (data_check->index_class == 2 || data_check->index_class == 3)) {
			  if (krit_8_5_8max > lambda_w/(k_x*lambda_uw_m)) {
				if (krit[13] < krit_8_5_8max) {  // критерий вычислен при проверке по нормальным напряжениям
				  index_flex_1_const = 1;
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->lambda_uw = lambda_uw;
				  Cp->k_x = k_x;
				  krit[13] = krit_8_5_8max;
				  nnel_krit[13] = elem_8_5_8;
				}
			  }
			  else {
				if (krit[13] < lambda_w/(k_x*lambda_uw_m)) {
				  index_flex_1_const = 0;
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->k_x = k_x;
				  krit[13] = lambda_w/(k_x*lambda_uw_m);
				  nnel_krit[13] = n_elem_rep;
				}
			  }
			}
			else {
				if (krit[13] < lambda_w/(k_x*lambda_uw_m)) {  // критерий вычислен при проверке по нормальным напряжениям
				  index_flex_1_const = 0;
				  krit[13] = lambda_w/(k_x*lambda_uw_m);
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->k_x = k_x;
				  nnel_krit[13] = n_elem_rep;
				}
			}
		  }
		  else {
			 index_flex_1_const = 2;
			 krit[13] = MAX(krit[13], -1);
		  }
		}
		// 14. Проверка устойчивости стенки переменной высоты, если устойчивость в плоскости более критична,
		//     чем устойчивость из плоскости
		// 15. Проверка устойчивости стенки постоянной высоты при с*fi_y <= fi_e
		//     (устойчивость из плоскости более критична чем устойчивость в плоскости)
		if (flag_check[14]) {
		  if (Fi_y_param.c_*Fi_y_param.fi_y <= Fi_e_param.fi_e && alfa_w > 0.5)  {   // alfa_w > 0.5) - Гибкая стенка недопустима
		   #ifdef INFMESSAGE_0
			if (krit[14] < lambda_w/(k_x*lambda_uw)) {
			  InfMessage(" Постоянная высота стенки с*fi_y <= f_e");
			  InfMessage("N_= " + FloatToStr(Round(N_*1e-3, 2)) + "; M_ =" + FloatToStr(Round(M_*1e-6,2)));
			  InfMessage("c_ " + FloatToStr(Round(Fi_y_param.c_, 3)) +"; fi_y =" +
					FloatToStr(Round(Fi_y_param.fi_y, 3)) + "; fi_e =" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
			  InfMessage("c_*fi_y=" + FloatToStr(Round(Fi_y_param.c_*Fi_y_param.fi_y, 3))+"; fi_e =" +
					FloatToStr(Round(Fi_e_param.fi_e, 3)));
			  InfMessage("lambda_w = "+FloatToStr(Round(lambda_w, 3)));
			  InfMessage("k_x = "+FloatToStr(Round(k_x, 3)));
			  InfMessage("lambda_uw = "+FloatToStr(Round(lambda_uw, 3)));
			  InfMessage("krit_15 = " + FloatToStr(Round(lambda_w/(k_x*lambda_uw), 3)) + "; n_elem =" + IntToStr(n_elem_rep));
			}
		   #endif
			if (m_exc > 5 && (data_check->index_class == 2 || data_check->index_class == 3)) {
			  if (krit_8_5_8max > lambda_w/(k_x*lambda_uw)) {
				if (krit[14] < krit_8_5_8max) {  // критерий вычислен при проверке по нормальным напряжениям
                  index_flex_1_const = 1;
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->k_x = k_x;
				  krit[14] = krit_8_5_8max;
				  nnel_krit[14] = elem_8_5_8;
				}
			  }
			  else {
				if (krit[14] < lambda_w/(k_x*lambda_uw)) {
				  index_flex_1_const = 0;
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->k_x = k_x;
				  krit[14] = lambda_w/(k_x*lambda_uw);
				  nnel_krit[14] = n_elem_rep;
				}
			  }
			}
			else {
				if (krit[14] < lambda_w/(k_x*lambda_uw)) {  // критерий вычислен при проверке по нормальным напряжениям
				  index_flex_1_const = 0;
				  Cp->lambda_uw_m = lambda_uw_m;
				  Cp->k_x = k_x;
				  krit[14] = lambda_w/(k_x*lambda_uw);
				  nnel_krit[14] = n_elem_rep;
				}
			}
		  }
		  else {
			 krit[14] = MAX(krit[14], -1);
		  }
		}
		if (flag_check[15]) {
		// 16. Проверка местной устойчивости внешнего пояса, п. 9.4.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
			  if (lambda_f1/(k_x*lambda_uf1) > krit[15]) {
				  Cp->lambda_f = lambda_f1;
				  Cp->lambda_uf = lambda_uf1;

			  }
			  MAXNNEL(krit[15], lambda_f1/(k_x*lambda_uf1), 15);
		  }
		  else
			krit[15] = MAX(krit[15], -1);
		}
		if (flag_check[16]) {
		// 17. Проверка местной устойчивости внутреннего пояса, п. 9.4.7.
		  double lambda_uf2, lambda_uf20, k_x0, sig_f2;

		  if (sigma_comm[2] < 0) {
			  sig_f2 = ABS(N_/param_netto.Ar + M_*(param_netto.Hp - param_netto.Zp)/param_netto.Izz);
			  lambda_uf20 = Fun_lambda_uf20(index_105, Ry, sig_f2, lambda_uw20);
			  lambda_uf2 = Fun_lambda_uf_cent_bend(Sect_Elem_Group[0].type_sect, lambda_cent, lambda_x[n_elem], lambda_uf20, m_x, Ry);
			  if ((ABS(N_))/param_netto.Ar<=0.1*Ry)
				k_x0 = 1.0;
			  else
				k_x0 = k_x;
		#ifdef INFMESSAGE
		InfMessage("lambda_f2 = "+FloatToStr(Round(lambda_f2, 3))+", lambda_uf2 = "+FloatToStr(Round(lambda_uf2, 3)));
		InfMessage("krit_17 = "+FloatToStr(Round(lambda_f2/(k_x0*lambda_uf2), 3)));
		#endif
			  if (lambda_f2/(k_x0*lambda_uf2) > krit[15]) {
				  Cp->lambda_f = lambda_f2;
				  Cp->lambda_uf = lambda_uf2;
			  }
			  MAXNNEL(krit[16], lambda_f2/(k_x0*lambda_uf2), 16);
		  }
		  else
            krit[16] = MAX(krit[16], -1);
        }
        if (flag_check[17]) {  // постоянная высота стенки
		// 18. Проверка предельной гибкости в плоскости поясов, табл. 33

		  MAXNNEL(krit[17], lambdaY[n_elem]/(k_*lambda_uy), 17);
        }
        if (flag_check[18]) {
		// 19. Проверка предельной гибкости в плоскости стенки, табл. 32
		  MAXNNEL(krit[18], lambdaX[n_elem]/(k_*lambda_ux), 18);
		}
        if (flag_check[19] || flag_check[20]) {
          rc = 0;
		  if (!data_check->flag_cont_ext || !data_check->flag_cont_int) {
			if (data_check->Qu_ == 0) {
              rc = 1;
            }
          }
          else {
            if (data_check->q_u_ == 0) {
              rc = 1;
            }
          }
		  if (rc>0) {
			#ifdef EMBRAC
			i = Application->MessageBox((L"Для выполнения проверок "+IntToStr(20)+" и "+IntToStr(21)+" должны быть заданы предельные значения несущей способности закрепляющих элементов").c_str(),
			L"Сжато-изгибаемые элементы", MB_OK | MB_ICONERROR);
			#else
			i = Application->MessageBox(("Для выполнения проверок "+IntToStr(20)+" и "+IntToStr(21)+" должны быть заданы предельные значения несущей способности закрепляющих элементов").c_str(),
			"Сжато-изгибаемые элементы", MB_OK | MB_ICONERROR);
			#endif
			return rc;
          }
		}
        if (flag_check[19]) {
        // 20. Проверка элементов, закрепляющих внешний пояс на Qfic, п. 8.4.5
		  double N_ext, krit19, fi, lambda_r;
          if (sigma_comm[0] < 0) {
            N_ext = bef_1*tef_1*Ry + 0.25*t_*h_*Ryw;
			lambda_r = (data_check->step_ext[n_elem]/(0.2887*bef_1))*sqrt(Ry/Ey);
            // Вычисление fi - коэффициент устойчивости внешнего пояся в плоскости поясов при центальном сжатии
			fi = Round(Fun_fi_713(RECTANCULAR, lambda_r, 0), 3);

			Qfic = GetQfic(Ey, Ry, N_ext, fi);
            if (!data_check->flag_cont_ext) {
              krit19 = Qfic/(data_check->Qu_*1000);
            }
            else {
			  krit19 = 3*Qfic/(data_check->len_ext*data_check->q_u_*1000);
            }
            MAXNNEL(krit[19], krit19, 19);
          }
          else {
			krit[19] = MAX(krit[19], -1);
          }
        }
		if (flag_check[20]) {
        // 21. Проверка элементов, закрепляющих внутренний пояс на Qfic, п. 8.4.5
          double N_int, krit20, fi, lambda_r;
          if (sigma_comm[2] < 0) {
            N_int = bef_2*tef_2*Ry + 0.25*t_*h_*Ryw;
			lambda_r = (data_check->step_int[n_elem]/(0.2887*bef_2))*sqrt(Ry/Ey);
			// Вычисление fi - коэффициент устойчивости внешнего пояся в плоскости поясов при центальном сжатии
            fi = Round(Fun_fi_713(RECTANCULAR, lambda_r, 0), 3);
            Qfic = GetQfic(Ey, Ry, N_int, fi);
            if (!data_check->flag_cont_int) {
			  krit20 = Qfic/(data_check->Qu_*1000);
            }
            else {
			  krit20 = 3*Qfic/(data_check->len_int*data_check->q_u_*1000);
			}
            MAXNNEL(krit[20], krit20, 20);
          }
		  else {
            krit[20] = MAX(krit[20], -1);
          }
		}
        if (flag_check[21]) {
        // 22. Проверка момента
          MAXNNEL(krit[21], M_/(2*M_c), 21);
        }
        memcpy((char*)&(Sect_Elem_Group[0].com_sect.dvutavr), (char*) &Sect_Elem_Copy, sizeof(SECT_DVUTAVR));
		if ((ABS(M_y)) > Mmax) {
		  Mmax = ABS(M_y);
		  Cp->fi_exy = fi_exy[n_elem];
        }

		for (int j=0; j<25; j++) {
		  if (krit[j] > krit_comp_max) {
			krit_comp_max = krit[j];
			RSU_comp_max = n_elem;
		  }
		}
	  }

	  if (lambda_w >= 2.3 && data_check->type_edge >= 0) {   // подобрать сечение ребер
		double step_max = 2.5*h_;

		Cp->edge_param[2][0] = edge_param[2][0] = Round(step_max, 0);    // шаг
		if (data_check->type_edge==0) {
		   Cp->edge_param[2][1] = edge_param[2][1] = (hef/20 + 50, 0); // ширина одностороннего
		}
		else {
		   Cp->edge_param[2][1] = edge_param[2][1] = (hef/30 + 40); // ширина парного
		}
		Cp->edge_param[2][2] = edge_param[2][2] = 2*Cp->edge_param[2][1]*sqrt(Ry/Ey); // ширина парного
	  }

	  #ifdef INFMESSAGE_1
	  int ne1_at_min = -1;
	  int ne2_at_min = -1;

	  sprintf(stroka,"ne1_at_min = %6d, Nf1_min=%6.1f кН, N1_at_min=%6.1f кН, M1_at_min=%8.1f кН*м, Ar1_at_min=%5.2f, Z1_at_min=%5.1f",
					  ne1_at_min, Nf1_min*1e-3, N1_at_min*1e-3, M1_at_min*1e-6, Ar1_at_min, Z1_at_min);
	  InfMessage("Сжато-изгибаемый, внешний пояс: "+(AnsiString)stroka);
	  sprintf(stroka,"ne2_at_min = %6d, Nf2_min=%6.1f кН, N2_at_min=%6.1f кН, M2_at_min=%8.1f кН*м, Ar2_at_min=%5.2f, Z2_at_min=%5.1f",
					  ne2_at_min, Nf2_min*1e-3, N2_at_min*1e-3, M2_at_min*1e-6, Ar2_at_min, Z2_at_min);
	  InfMessage("Сжато-изгибаемый, внешний пояс: "+(AnsiString)stroka);
	  sprintf(stroka,"Mx =%8.1f кН*м, N=%6.1f кН, fi_y=%5.2f, c=%5.2f, fi_e=%5.2f, lambda_uw=%5.2f, A=%6.0f, Ry=%6.0f, gamma_c=%6.2f",
					  M_at5*1e-6, N_at5*1e-3, fy_at5, c_at5, fe_at5, lambda_uw_at5, Ar_at5, Ry, data_check->gamma_c);
	  InfMessage("Сжато-изгибаемый, устойчивость в плоскости: "+(AnsiString)stroka);
	  sprintf(stroka,"Mx =%8.1f кН*м, M_c=%8.1f кН*м, N=%6.1f кН, c=%5.2f, fi_y=%5.2f, A=%6.0f, Ry=%6.0f, gamma_c=%6.2f", M_at6*1e-6, Mc_at6*1e-6, N_at6*1e-3, c_at6, fy_at6,
					 Ar_at6, Ry, data_check->gamma_c);
	  InfMessage("Сжато-изгибаемый, устойчивость из плоскости: "+(AnsiString)stroka);
	  #endif

	  int n_krit;
	  n_krit = 22;
	  krit[n_krit] = -1;
	  n_elem = ListElem_RSU[RSU_comp_max];
		  Cp->num_elem[2] = n_elem;
			Cp->hw = h_;
			Cp->hef = hef;
			Cp->RSU[2][0] = Elem_RSU[RSU_comp_max][0];
			Cp->RSU[2][2] = Elem_RSU[RSU_comp_max][2];
			Cp->RSU[2][3] = Elem_RSU[RSU_comp_max][3];
			Cp->RSU[2][4] = Elem_RSU[RSU_comp_max][4];
			Cp->RSU[2][5] = Elem_RSU[RSU_comp_max][5];
			Cp->RSU[2][6] = M_c*1e-6;
			strcpy(Cp->Steel, MaterPropU_prof.title);
			Cp->Ryn = steel_param.Ryn;
			Cp->bef = bef_1;
			Cp->Ry = Ry;
			Cp->Ryw = Ryw;
			Cp->Rs = Rsw;
			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_ux = lambda_ux;
		    Cp->lambda_uy = lambda_uy;
			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->fi_e = fi_e[n_elem];
			Cp->fi_ey = fi_ey[n_elem];
			Cp->fi_exy = fi_exy[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_b = Fi_y_param.fi_b;
			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_;

   			// Проверка поясных швов
			if (flag_check[21] && data_check->index_nf >=0) {
			   double krit_21 = CheckWeld_CV(data_check, Ry, 0, NRSU-1, fi_x, Checked_weld, &n_elem_rep);
			   MAXNNEL(krit[21], krit_21, 21);
			}

   	        memcpy((char*)&Data_check_U, (char*)data_check, sizeof(DATA_CHECK_U));

   }









