自学教程：C++ Dtype函数代码示例

/* {WSF_ANY}.string_representation */EIF_TYPED_VALUE F334_6432 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "string_representation";	RTEX;	EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE tr2 = NULL;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		RTLI(5);	RTLR(0,loc1);	RTLR(1,Current);	RTLR(2,tr1);	RTLR(3,tr2);	RTLR(4,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);		RTEAA(l_feature_name, 333, Current, 1, 0, 11063);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(333, Current, 11063);	RTIV(Current, RTAL);	RTHOOK(1);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(5264, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	loc1 = RTCCL(tr1);	if (EIF_TEST(loc1)) {		RTHOOK(2);		RTDBGAL(Current, 0, 0xF8000139, 0,0); /* Result */				tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(8, "generating_type", loc1))(loc1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(5161, "to_string_32", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		Result = (EIF_REFERENCE) RTCCL(tr2);	} else {		RTHOOK(3);		RTDBGAL(Current, 0, 0xF8000139, 0,0); /* Result */				tr1 = RTMS_EX_H("Void",4,1450142052);		tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4615, "as_string_32", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		Result = (EIF_REFERENCE) RTCCL(tr2);	}	RTVI(Current, RTAL);	RTRS;	RTHOOK(4);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(3);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef up1}

/* {EXCEPTION}.description */EIF_TYPED_VALUE F90_1559 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "description";	RTEX;	struct eif_ex_33 sloc1;	EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;	EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;	EIF_REFERENCE loc3 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_TYPED_VALUE ur2x = {{0}, SK_REF};#define ur2 ur2x.it_r	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};#define ui4_2 ui4_2x.it_i4	EIF_TYPED_VALUE ub1x = {{0}, SK_BOOL};#define ub1 ub1x.it_b	EIF_REFERENCE tr1 = NULL;	EIF_INTEGER_32 ti4_1;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		memset (&sloc1.overhead, 0, OVERHEAD + 0);	sloc1.overhead.ov_flags = EO_EXP | EO_STACK;	RT_DFS(&sloc1.overhead, 33);	RTLI(8);	RTLR(0,loc3);	RTLR(1,Current);	RTLR(2,tr1);	RTLR(3,loc2);	RTLR(4,loc1);	RTLR(5,ur1);	RTLR(6,ur2);	RTLR(7,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);	RTLU(SK_REF, &loc2);	RTLU(SK_REF, &loc3);		RTEAA(l_feature_name, 89, Current, 3, 0, 1495);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(89, Current, 1495);	RTIV(Current, RTAL);	wstdinit(loc1,loc1);	RTLXI(loc1);	RTHOOK(1);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1453, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	loc3 = RTCCL(tr1);	if (EIF_TEST(loc3)) {		RTHOOK(2);		RTDBGAL(Current, 2, 0xF8000107, 0, 0); /* loc2 */				tr1 = RTLN(263);		ti4_1 = *(EIF_INTEGER_32 *)(loc3 + RTVA(1811, "count", loc3));		ui4_1 = ti4_1;		(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(4745, Dtype(tr1)))(tr1, ui4_1x);		RTNHOOK(2,1);		loc2 = (EIF_REFERENCE) RTCCL(tr1);		RTHOOK(3);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1808, "managed_data", loc3))(loc3)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		ur1 = RTCCL(tr1);		ui4_1 = ((EIF_INTEGER_32) 0L);		ti4_1 = *(EIF_INTEGER_32 *)(loc3 + RTVA(1811, "count", loc3));		ui4_2 = (EIF_INTEGER_32) (ti4_1 - ((EIF_INTEGER_32) 1L));		ub1 = (EIF_BOOLEAN) 0;		ur2 = RTCCL(loc2);		(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(558, "utf_8_0_subpointer_into_escaped_string_32", loc1))(loc1, ur1x, ui4_1x, ui4_2x, ub1x, ur2x);		RTHOOK(4);		RTDBGAL(Current, 0, 0xF80000FE, 0,0); /* Result */				Result = (EIF_REFERENCE) RTCCL(loc2);	}	RTVI(Current, RTAL);	RTRS;	RTHOOK(5);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(5);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef up1#undef ur1#undef ur2#undef ui4_1#undef ui4_2#undef ub1}

/* {EXCEPTION}.set_description */void F90_1570 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x){	GTCX	char *l_feature_name = "set_description";	RTEX;	struct eif_ex_33 sloc1;	EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;	EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;	EIF_REFERENCE loc3 = (EIF_REFERENCE) 0;	EIF_REFERENCE loc4 = (EIF_REFERENCE) 0;	EIF_REFERENCE loc5 = (EIF_REFERENCE) 0;#define arg1 arg1x.it_r	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_TYPED_VALUE ur2x = {{0}, SK_REF};#define ur2 ur2x.it_r	EIF_TYPED_VALUE ur3x = {{0}, SK_REF};#define ur3 ur3x.it_r	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_REFERENCE tr1 = NULL;	EIF_INTEGER_32 ti4_1;	EIF_BOOLEAN tb1;	EIF_BOOLEAN tb2;	EIF_BOOLEAN tb3;	RTCDT;	RTSN;	RTDA;	RTLD;			memset (&sloc1.overhead, 0, OVERHEAD + 0);	sloc1.overhead.ov_flags = EO_EXP | EO_STACK;	RT_DFS(&sloc1.overhead, 33);	RTLI(11);	RTLR(0,arg1);	RTLR(1,loc3);	RTLR(2,Current);	RTLR(3,tr1);	RTLR(4,loc2);	RTLR(5,loc1);	RTLR(6,ur1);	RTLR(7,ur2);	RTLR(8,ur3);	RTLR(9,loc4);	RTLR(10,loc5);	RTLU (SK_VOID, NULL);	RTLU(SK_REF,&arg1);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);	RTLU(SK_REF, &loc2);	RTLU(SK_REF, &loc3);	RTLU(SK_REF, &loc4);	RTLU(SK_REF, &loc5);		RTEAA(l_feature_name, 89, Current, 5, 1, 1474);	RTSA(dtype);	RTSC;	RTME(dtype, 0);	RTGC;	RTDBGEAA(89, Current, 1474);	if (arg1) {		RTCC(arg1, 89, l_feature_name, 1, eif_non_attached_type(254));	}	RTIV(Current, RTAL);	wstdinit(loc1,loc1);	RTLXI(loc1);	RTHOOK(1);	if ((EIF_BOOLEAN)(arg1 != NULL)) {		RTHOOK(2);		RTDBGAL(Current, 3, 0xF800009D, 0, 0); /* loc3 */				tr1 = RTLNSMART(eif_non_attached_type(RTWCT(1453, dtype, Dftype(Current))));		ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4784, "count", arg1))(arg1)).it_i4);		ui4_1 = ti4_1;		(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(1789, Dtype(tr1)))(tr1, ui4_1x);		RTNHOOK(2,1);		loc3 = (EIF_REFERENCE) RTCCL(tr1);		RTHOOK(3);		RTDBGAL(Current, 2, 0xF800035B, 0, 0); /* loc2 */				{			static EIF_TYPE_INDEX typarr0[] = {859,246,0xFFFF};			EIF_TYPE_INDEX typres0;			static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;						typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(Dftype(Current), typarr0)));			tr1 = RTLN(typres0);		}		ui4_1 = ((EIF_INTEGER_32) 0L);		(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(1914, Dtype(tr1)))(tr1, ui4_1x);		RTNHOOK(3,1);		loc2 = (EIF_REFERENCE) RTCCL(tr1);		RTHOOK(4);		ur1 = RTCCL(arg1);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(1808, "managed_data", loc3))(loc3)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		ur2 = RTCCL(tr1);//.........这里部分代码省略.........

void ROIPoolingLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,      const vector<Blob<Dtype>*>& top) {  const Dtype* bottom_data = bottom[0]->cpu_data();  const Dtype* bottom_rois = bottom[1]->cpu_data();  // Number of ROIs  int num_rois = bottom[1]->num();  int batch_size = bottom[0]->num();  int top_count = top[0]->count();  Dtype* top_data = top[0]->mutable_cpu_data();  caffe_set(top_count, Dtype(-FLT_MAX), top_data);  int* argmax_data = max_idx_.mutable_cpu_data();  caffe_set(top_count, -1, argmax_data);  // For each ROI R = [batch_index x1 y1 x2 y2]: max pool over R  for (int n = 0; n < num_rois; ++n) {    int roi_batch_ind = bottom_rois[0];    int roi_start_w = round(bottom_rois[1] * spatial_scale_);    int roi_start_h = round(bottom_rois[2] * spatial_scale_);    int roi_end_w = round(bottom_rois[3] * spatial_scale_);    int roi_end_h = round(bottom_rois[4] * spatial_scale_);    CHECK_GE(roi_batch_ind, 0);    CHECK_LT(roi_batch_ind, batch_size);    int roi_height = max(roi_end_h - roi_start_h + 1, 1);    int roi_width = max(roi_end_w - roi_start_w + 1, 1);    const Dtype bin_size_h = static_cast<Dtype>(roi_height)                             / static_cast<Dtype>(pooled_height_);    const Dtype bin_size_w = static_cast<Dtype>(roi_width)                             / static_cast<Dtype>(pooled_width_);    const Dtype* batch_data = bottom_data + bottom[0]->offset(roi_batch_ind);    for (int c = 0; c < channels_; ++c) {      for (int ph = 0; ph < pooled_height_; ++ph) {        for (int pw = 0; pw < pooled_width_; ++pw) {          // Compute pooling region for this output unit:          //  start (included) = floor(ph * roi_height / pooled_height_)          //  end (excluded) = ceil((ph + 1) * roi_height / pooled_height_)          int hstart = static_cast<int>(floor(static_cast<Dtype>(ph)                                              * bin_size_h));          int wstart = static_cast<int>(floor(static_cast<Dtype>(pw)                                              * bin_size_w));          int hend = static_cast<int>(ceil(static_cast<Dtype>(ph + 1)                                           * bin_size_h));          int wend = static_cast<int>(ceil(static_cast<Dtype>(pw + 1)                                           * bin_size_w));          hstart = min(max(hstart + roi_start_h, 0), height_);          hend = min(max(hend + roi_start_h, 0), height_);          wstart = min(max(wstart + roi_start_w, 0), width_);          wend = min(max(wend + roi_start_w, 0), width_);          bool is_empty = (hend <= hstart) || (wend <= wstart);          const int pool_index = ph * pooled_width_ + pw;          if (is_empty) {            top_data[pool_index] = 0;            argmax_data[pool_index] = -1;          }          for (int h = hstart; h < hend; ++h) {            for (int w = wstart; w < wend; ++w) {              const int index = h * width_ + w;              if (batch_data[index] > top_data[pool_index]) {                top_data[pool_index] = batch_data[index];                argmax_data[pool_index] = index;              }            }          }        }      }      // Increment all data pointers by one channel      batch_data += bottom[0]->offset(0, 1);      top_data += top[0]->offset(0, 1);      argmax_data += max_idx_.offset(0, 1);    }    // Increment ROI data pointer    bottom_rois += bottom[1]->offset(1);  }}

inline int8_t caffe_sign(Dtype val) {  return (Dtype(0) < val) - (val < Dtype(0));}

void BatchNormLayer<Dtype, MItype, MOtype>::Forward_cpu(    const vector<Blob<MItype>*>& bottom,    const vector<Blob<MOtype>*>& top) {  const Dtype* bottom_data = bottom[0]->cpu_data();  Dtype* top_data = top[0]->mutable_cpu_data();  int_tp num = bottom[0]->shape(0);  int_tp spatial_dim = bottom[0]->count() / (bottom[0]->shape(0) * channels_);  if (bottom[0] != top[0]) {    caffe_copy(bottom[0]->count(), bottom_data, top_data);  }  if (use_global_stats_) {    // use the stored mean/variance estimates.    const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ?        0 : 1 / this->blobs_[2]->cpu_data()[0];    caffe_scale(variance_.count(), scale_factor,                    this->blobs_[0]->cpu_data(), mean_.mutable_cpu_data());    caffe_scale(variance_.count(), scale_factor,                    this->blobs_[1]->cpu_data(), variance_.mutable_cpu_data());  } else {    // compute mean    caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,                          1. / (num * spatial_dim), bottom_data,                          spatial_sum_multiplier_.cpu_data(), 0.,                          num_by_chans_.mutable_cpu_data());    caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,        num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,        mean_.mutable_cpu_data());  }  // subtract mean  caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,      batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0.,      num_by_chans_.mutable_cpu_data());  caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,      spatial_dim, 1, -1, num_by_chans_.cpu_data(),      spatial_sum_multiplier_.cpu_data(), 1., top_data);  if (!use_global_stats_) {    // compute variance using var(X) = E((X-EX)^2)    caffe_sqr<Dtype>(top[0]->count(), top_data,                     temp_.mutable_cpu_data());  // (X-EX)^2    caffe_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,                          1. / (num * spatial_dim), temp_.cpu_data(),                          spatial_sum_multiplier_.cpu_data(), 0.,                          num_by_chans_.mutable_cpu_data());    caffe_gemv<Dtype>(CblasTrans, num, channels_, 1.,        num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,        variance_.mutable_cpu_data());  // E((X_EX)^2)    // compute and save moving average    this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_;    this->blobs_[2]->mutable_cpu_data()[0] += 1;    caffe_axpby(mean_.count(), Dtype(1), mean_.cpu_data(),        moving_average_fraction_, this->blobs_[0]->mutable_cpu_data());    int_tp m = bottom[0]->count()/channels_;    Dtype bias_correction_factor = m > 1 ? Dtype(m)/(m-1) : 1;    caffe_axpby(variance_.count(), bias_correction_factor,        variance_.cpu_data(), moving_average_fraction_,        this->blobs_[1]->mutable_cpu_data());  }  // normalize variance  caffe_add_scalar(variance_.count(), eps_, variance_.mutable_cpu_data());  caffe_sqrt(variance_.count(), variance_.cpu_data(),             variance_.mutable_cpu_data());  // replicate variance to input size  caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,                        batch_sum_multiplier_.cpu_data(), variance_.cpu_data(),                        0., num_by_chans_.mutable_cpu_data());  caffe_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,                        spatial_dim, 1, 1., num_by_chans_.cpu_data(),                        spatial_sum_multiplier_.cpu_data(), 0.,                        temp_.mutable_cpu_data());  caffe_div(temp_.count(), top_data, temp_.cpu_data(), top_data);  // TODO(cdoersch): The caching is only needed because later in-place layers  //                 might clobber the data.  Can we skip this if they won't?  caffe_copy(x_norm_.count(), top_data, x_norm_.mutable_cpu_data());}

/* {READABLE_INDEXABLE}.new_cursor */EIF_TYPED_VALUE F682_12810 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "new_cursor";	RTEX;	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTCDT;	RTSN;	RTDA;	RTLD;		RTLI(4);	RTLR(0,Current);	RTLR(1,tr1);	RTLR(2,ur1);	RTLR(3,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);		RTEAA(l_feature_name, 681, Current, 0, 0, 5970);	RTSA(dtype);	RTSC;	RTME(dtype, 0);	RTGC;	RTDBGEAA(681, Current, 5970);	RTIV(Current, RTAL);	RTHOOK(1);	RTDBGAL(Current, 0, 0xF80002A6, 0,0); /* Result */		{		EIF_TYPE_INDEX typarr0[] = {678,0,0xFFFF};		EIF_TYPE_INDEX typres0;		typarr0[1] = RTWCT(11522, dtype, Dftype(Current));				typres0 = eif_compound_id(Dftype(Current), typarr0);		tr1 = RTLN(typres0);	}	ur1 = RTCCL(Current);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(11834, Dtype(tr1)))(tr1, ur1x);	RTNHOOK(1,1);	Result = (EIF_REFERENCE) RTCCL(tr1);	RTHOOK(2);	(FUNCTION_CAST(void, (EIF_REFERENCE)) RTVF(11851, "start", Result))(Result);	if (RTAL & CK_ENSURE) {		RTHOOK(3);		RTCT("result_attached", EX_POST);		if ((EIF_BOOLEAN)(Result != NULL)) {			RTCK;		} else {			RTCF;		}	}	RTVI(Current, RTAL);	RTRS;	RTHOOK(4);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(2);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef ur1}

/* {INET_ADDRESS_IMPL_V6}.local_host_name */EIF_TYPED_VALUE F865_6949 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "local_host_name";	RTEX;	EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_POINTER tp1;	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		RTLI(4);	RTLR(0,loc1);	RTLR(1,tr1);	RTLR(2,Result);	RTLR(3,Current);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);		RTEAA(l_feature_name, 864, Current, 1, 0, 12484);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(864, Current, 12484);	RTIV(Current, RTAL);	RTHOOK(1);	RTDBGAL(Current, 1, 0xF8000095, 0, 0); /* loc1 */		tr1 = RTLN(149);	ui4_1 = ((EIF_INTEGER_32) 256L);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWPC(260, 0, Dtype(tr1)))(tr1, ui4_1x);	RTNHOOK(1,1);	loc1 = (EIF_REFERENCE) RTCCL(tr1);	RTHOOK(2);	tp1 = *(EIF_POINTER *)(loc1 + RTVPA(260, 6, "item", loc1));	up1 = tp1;	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(864, 35, Dtype(Current)))(Current, up1x);	RTHOOK(3);	RTDBGAL(Current, 0, 0xF80000DA, 0,0); /* Result */		tr1 = RTLN(218);	tp1 = *(EIF_POINTER *)(loc1 + RTVPA(260, 6, "item", loc1));	up1 = tp1;	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWPC(335, 2, Dtype(tr1)))(tr1, up1x);	RTNHOOK(3,1);	Result = (EIF_REFERENCE) RTCCL(tr1);	RTVI(Current, RTAL);	RTRS;	RTHOOK(4);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(3);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef up1#undef ui4_1}

void DataTransformer<Dtype>::Transform(Blob<Dtype>* input_blob,                                       Blob<Dtype>* transformed_blob) {  const int crop_size = param_.crop_size();  const int input_num = input_blob->num();  const int input_channels = input_blob->channels();  const int input_height = input_blob->height();  const int input_width = input_blob->width();  if (transformed_blob->count() == 0) {    // Initialize transformed_blob with the right shape.    if (crop_size) {      transformed_blob->Reshape(input_num, input_channels,                                crop_size, crop_size);    } else {      transformed_blob->Reshape(input_num, input_channels,                                input_height, input_width);    }  }  const int num = transformed_blob->num();  const int channels = transformed_blob->channels();  const int height = transformed_blob->height();  const int width = transformed_blob->width();  const int size = transformed_blob->count();  CHECK_LE(input_num, num);  CHECK_EQ(input_channels, channels);  CHECK_GE(input_height, height);  CHECK_GE(input_width, width);  const Dtype scale = param_.scale();  const bool do_mirror = param_.mirror() && Rand(2);  const bool has_mean_file = param_.has_mean_file();  const bool has_mean_values = mean_values_.size() > 0;  int h_off = 0;  int w_off = 0;  if (crop_size) {    CHECK_EQ(crop_size, height);    CHECK_EQ(crop_size, width);    // We only do random crop when we do training.    if (phase_ == TRAIN) {      h_off = Rand(input_height - crop_size + 1);      w_off = Rand(input_width - crop_size + 1);    } else {      h_off = (input_height - crop_size) / 2;      w_off = (input_width - crop_size) / 2;    }  } else {    CHECK_EQ(input_height, height);    CHECK_EQ(input_width, width);  }  Dtype* input_data = input_blob->mutable_cpu_data();  if (has_mean_file) {    CHECK_EQ(input_channels, data_mean_.channels());    CHECK_EQ(input_height, data_mean_.height());    CHECK_EQ(input_width, data_mean_.width());    for (int n = 0; n < input_num; ++n) {      int offset = input_blob->offset(n);      caffe_sub(data_mean_.count(), input_data + offset,            data_mean_.cpu_data(), input_data + offset);    }  }  if (has_mean_values) {    CHECK(mean_values_.size() == 1 || mean_values_.size() == input_channels) <<     "Specify either 1 mean_value or as many as channels: " << input_channels;    if (mean_values_.size() == 1) {      caffe_add_scalar(input_blob->count(), -(mean_values_[0]), input_data);    } else {      for (int n = 0; n < input_num; ++n) {        for (int c = 0; c < input_channels; ++c) {          int offset = input_blob->offset(n, c);          caffe_add_scalar(input_height * input_width, -(mean_values_[c]),            input_data + offset);        }      }    }  }  Dtype* transformed_data = transformed_blob->mutable_cpu_data();  for (int n = 0; n < input_num; ++n) {    int top_index_n = n * channels;    int data_index_n = n * channels;    for (int c = 0; c < channels; ++c) {      int top_index_c = (top_index_n + c) * height;      int data_index_c = (data_index_n + c) * input_height + h_off;      for (int h = 0; h < height; ++h) {        int top_index_h = (top_index_c + h) * width;        int data_index_h = (data_index_c + h) * input_width + w_off;        if (do_mirror) {          int top_index_w = top_index_h + width - 1;          for (int w = 0; w < width; ++w) {            transformed_data[top_index_w-w] = input_data[data_index_h + w];          }        } else {          for (int w = 0; w < width; ++w) {//.........这里部分代码省略.........

void TripletLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,  const vector<Blob<Dtype>*>& top) {  Dtype eps = this->layer_param_.triplet_loss_param().eps();  Dtype loss = 0;  Dtype margin = this->layer_param_.triplet_loss_param().margin();  caffe_cpu_gemm(CblasNoTrans, CblasTrans, sample_num_, sample_num_,      feature_dim_, Dtype(1), bottom[0]->cpu_data(),      bottom[0]->cpu_data(), Dtype(0),      inner_matrix_.mutable_cpu_data());  for (int i = 0; i < triplet_num_; ++i) {    int a_idx = bottom[1]->cpu_data()[i * 3];    int p_idx = bottom[1]->cpu_data()[i * 3 + 1];    int n_idx = bottom[1]->cpu_data()[i * 3 + 2];    const Dtype *a_pointer = bottom[0]->cpu_data() + a_idx * feature_dim_;    const Dtype *p_pointer = bottom[0]->cpu_data() + p_idx * feature_dim_;    const Dtype *n_pointer = bottom[0]->cpu_data() + n_idx * feature_dim_;    const Dtype *inner_matrix_data = inner_matrix_.cpu_data();    Dtype a_norm = sqrt(inner_matrix_data[a_idx * sample_num_ + a_idx] + eps);    Dtype p_norm = sqrt(inner_matrix_data[p_idx * sample_num_ + p_idx] + eps);    Dtype n_norm = sqrt(inner_matrix_data[n_idx * sample_num_ + n_idx] + eps);    Dtype inner_ap = inner_matrix_data[a_idx * sample_num_ + p_idx];    Dtype inner_an = inner_matrix_data[a_idx * sample_num_ + n_idx];    Dtype dist_ap = inner_ap / (a_norm * p_norm);    Dtype dist_an = inner_an / (a_norm * n_norm);    if (dist_ap - dist_an - margin < 0) {      ComputeDiff_cpu(a_pointer, p_pointer, a_norm,          p_norm, inner_ap, diff_ap_.mutable_cpu_data());      ComputeDiff_cpu(a_pointer, n_pointer, a_norm,          n_norm, inner_an, diff_an_.mutable_cpu_data());      ComputeDiff_cpu(p_pointer, a_pointer, p_norm,          a_norm, inner_ap, diff_pa_.mutable_cpu_data());      ComputeDiff_cpu(n_pointer, a_pointer, n_norm,          a_norm, inner_an, diff_na_.mutable_cpu_data());      caffe_cpu_axpby(feature_dim_, Dtype(1),          diff_an_.cpu_data(), Dtype(1),          bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));      caffe_cpu_axpby(feature_dim_, Dtype(-1),          diff_ap_.cpu_data(), Dtype(1),          bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));      caffe_cpu_axpby(feature_dim_, Dtype(-1),          diff_pa_.cpu_data(), Dtype(1),          bottom_diff_.mutable_cpu_data() + (p_idx * feature_dim_));      caffe_cpu_axpby(feature_dim_, Dtype(1),          diff_na_.cpu_data(), Dtype(1),          bottom_diff_.mutable_cpu_data() + (n_idx * feature_dim_));      loss += dist_an + margin - dist_ap;    }  }  //Dtype scalar = Dtype(1) / triplet_num_;  Dtype scalar = Dtype(1) / sample_num_;  top[0]->mutable_cpu_data()[0] = loss * scalar;}

/* {INET_ADDRESS_IMPL_V6}.loopback_address */EIF_TYPED_VALUE F865_6951 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "loopback_address";	RTEX;	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_TYPED_VALUE ur2x = {{0}, SK_REF};#define ur2 ur2x.it_r	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE tr2 = NULL;	EIF_REFERENCE tr3 = NULL;	EIF_REFERENCE tr4 = NULL;	EIF_NATURAL_8 tu1_1;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		RTLI(8);	RTLR(0,tr1);	RTLR(1,tr2);	RTLR(2,ur1);	RTLR(3,Current);	RTLR(4,tr3);	RTLR(5,tr4);	RTLR(6,ur2);	RTLR(7,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);		RTEAA(l_feature_name, 864, Current, 0, 0, 12486);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(864, Current, 12486);	RTIV(Current, RTAL);	RTHOOK(1);	RTDBGAL(Current, 0, 0xF8000361, 0,0); /* Result */		tr1 = RTLN(866);	tr2 = RTMS_EX_H("::1",3,3815985);	ur1 = tr2;	ui4_1 = ((EIF_INTEGER_32) 16L);	{		static EIF_TYPE_INDEX typarr0[] = {864,706,195,0xFFFF};		EIF_TYPE_INDEX typres0;		static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;				typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(Dftype(Current), 706, typarr0)));		tr4 = RTLNSP2(eif_non_attached_type(typres0),0,ui4_1,sizeof(EIF_NATURAL_8), EIF_TRUE);		RT_SPECIAL_COUNT(tr4) = 16L;		memset(tr4, 0, RT_SPECIAL_VISIBLE_SIZE(tr4));	}	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+0) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+1) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+2) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+3) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+4) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+5) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+6) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+7) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+8) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+9) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+10) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+11) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+12) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+13) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 0L);	*((EIF_NATURAL_8 *)tr4+14) = (EIF_NATURAL_8) tu1_1;	tu1_1 = (EIF_NATURAL_8) ((EIF_INTEGER_32) 1L);	*((EIF_NATURAL_8 *)tr4+15) = (EIF_NATURAL_8) tu1_1;	tr3 = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE))  RTWPF(2, 8, Dtype(tr4)))(tr4).it_r;	ur2 = RTCCL(tr3);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(866, 43, Dtype(tr1)))(tr1, ur1x, ur2x);	RTNHOOK(1,1);	Result = (EIF_REFERENCE) RTCCL(tr1);	RTVI(Current, RTAL);	RTRS;	RTHOOK(2);	RTDBGLE;//.........这里部分代码省略.........

void TripletLossLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,  const vector<Blob<Dtype>*>& top) {  caffe_set(bottom[0]->count(), Dtype(0), bottom_diff_.mutable_cpu_data());  vector<int> loss_shape(0);  top[0]->Reshape(loss_shape);}

void ContrastiveLossLayer<Dtype>::Forward_cpu(    const vector<Blob<Dtype>*>& bottom,    vector<Blob<Dtype>*>* top) {  int count = bottom[0]->count();  caffe_sub(      count,      bottom[0]->cpu_data(),  // a      bottom[1]->cpu_data(),  // b      diff_.mutable_cpu_data());  // a_i-b_i  const int channels = bottom[0]->channels();  /*   * margin refers to the maximum value of energy -- parameter Q in the paper   */   printf("CLL : the values of a_i are /n");    for (int i = 0; i < bottom[0]->num(); ++i) {       for (int j = 0; j < channels; ++j) {          printf("%f /t ",(float) bottom[0]->cpu_data()[i*channels+j] );      }    }   printf("CLL : End printing values of a_i/n");  printf("CLL : the values of b_i are /n");    for (int i = 0; i < bottom[1]->num(); ++i) {       for (int j = 0; j < channels; ++j) {          printf("%f /t ",(float) bottom[1]->cpu_data()[i*channels+j] );      }    }   printf("CLL : End printing values of b_i/n");   printf("CLL : the diff values for the input vector are /n");   for(int temp = 0 ; temp < count ; temp++){    printf("%f /t ",(float) diff_.mutable_cpu_data()[temp] );   }   printf("CLL : End printing the diff values/n");  Dtype margin = this->layer_param_.contrastive_loss_param().margin();  //margin = Dtype(1000);  Dtype loss(0.0);  for (int i = 0; i < bottom[0]->num(); ++i) {    dist_sq_.mutable_cpu_data()[i] = caffe_cpu_asum(channels,        diff_.cpu_data() + (i*channels));   printf("CLL : values of L1 norm are , %f /n", (float) dist_sq_.mutable_cpu_data()[i] );    /*      * 1 is similar pair, 0 is impostor pair.     * The paper follows opposite notation     */    printf("CLL: label : %d /n", bottom[2]->cpu_data()[i]);    if (static_cast<int>(bottom[2]->cpu_data()[i])) {  // similar pairs            loss += Dtype(2) / margin * dist_sq_.cpu_data()[i] * dist_sq_.cpu_data()[i];      printf(" CLL: loss computed : %f/n", dist_sq_.cpu_data()[i]);        } else {  // dissimilar pairs      //loss += std::max(margin-dist_sq_.cpu_data()[i], Dtype(0.0));      printf("CLL : the exponent of 1 is : %f /n",exp(Dtype(1)));      printf("CLL : the exponent of -1 is : %f /n", exp(Dtype(-1)));            loss += Dtype(2) * margin * exp(-Dtype(2.77) / margin * dist_sq_.cpu_data()[i]);       printf(" CLL: loss computed : %f/n", dist_sq_.cpu_data()[i]);    }    printf("CLL: value of label : %d /n", static_cast<int>(bottom[2]->cpu_data()[i]));    printf("CLL: value of margin : %f /n", (float) margin);  }  loss = loss / static_cast<Dtype>(bottom[0]->num());  printf("CLL: value of loss : %f /n", loss);  (*top)[0]->mutable_cpu_data()[0] = loss;}

void ContrastiveLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,    const vector<bool>& propagate_down, vector<Blob<Dtype>*>* bottom) {  Dtype margin = this->layer_param_.contrastive_loss_param().margin();  //margin = Dtype(1000);  for (int i = 0; i < 2; ++i) {    if (propagate_down[i]) {      const Dtype sign = (i == 0) ? 1 : -1;      const Dtype alpha = sign * top[0]->cpu_diff()[0] /          static_cast<Dtype>((*bottom)[i]->num());         // printf("CLL:value of alpha is %f /n", (float)alpha);         // printf("CLL:value of CPU diff is %f /n", (float) top[0]->cpu_diff()[0]);         // printf("CLL:value of bottom num is %d /n", (int) (*bottom)[i]->num());      int num = (*bottom)[i]->num();      int channels = (*bottom)[i]->channels();      for (int j = 0; j < num; ++j) {        Dtype* bout = (*bottom)[i]->mutable_cpu_diff();        if (static_cast<int>((*bottom)[2]->cpu_data()[j])) {  // similar pairs          for(int k = 0 ; k < channels ; k ++){            Dtype gradient_sign = diff_.cpu_data()[(j*channels) + k] > 0 ? 1 : -1;            bout[(j*channels) + k] += alpha * dist_sq_.mutable_cpu_data()[j]                                     * gradient_sign * 4 / margin;          }          /*          caffe_cpu_axpby(              channels,              alpha,              diff_.cpu_data() + (j*channels),              Dtype(0.0),              bout + (j*channels));          */        } else {  // dissimilar pairs                    for(int k = 0 ; k < channels ; k ++){            Dtype gradient_sign = diff_.cpu_data()[(j*channels) + k] > 0 ? 1 : -1;            bout[(j*channels) + k] += alpha * Dtype(2) * -Dtype(2.77)                                     * exp(-Dtype(2.77) / margin * dist_sq_.mutable_cpu_data()[j] )                                    * gradient_sign;          }          /*          if ((margin-dist_sq_.cpu_data()[j]) > Dtype(0.0)) {            caffe_cpu_axpby(                channels,                -alpha,                diff_.cpu_data() + (j*channels),                Dtype(0.0),                bout + (j*channels));          } else {            caffe_set(channels, Dtype(0), bout + (j*channels));          }          */        }      }    }  }/*  // print values for debugging   for (int i = 0; i < 2; ++i) {    int num = (*bottom)[i]->num();      int channels = (*bottom)[i]->channels();      for (int j = 0; j < num; ++j) {        Dtype* bout = (*bottom)[i]->mutable_cpu_diff();       // if (static_cast<int>((*bottom)[2]->cpu_data()[j])) {  // similar pairs          for(int k = 0 ; k < channels ; k ++){            printf("CLL: Sample Num : %d, isSimilarPair : %d /n",j,static_cast<int>((*bottom)[2]->cpu_data()[j]));            printf("CLL: Bottom Blob Num : %d , Channel Num : %d , Gradient : %f /n", i , k, (float) bout[(j*channels) + k]);          }      }  }  */}

//.........这里部分代码省略.........	EIF_INTEGER_32 ti4_1;	EIF_BOOLEAN tb1;	EIF_CHARACTER_8 tc1;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTCFDT;	RTCDT;	RTSN;	RTDA;	RTLD;			RTLI(9);	RTLR(0,arg1);	RTLR(1,ur1);	RTLR(2,Current);	RTLR(3,tr1);	RTLR(4,tr2);	RTLR(5,loc5);	RTLR(6,loc4);	RTLR(7,tr3);	RTLR(8,Result);	RTLU (SK_REF, &Result);	RTLU(SK_REF,&arg1);	RTLU (SK_REF, &Current);	RTLU(SK_INT32, &loc1);	RTLU(SK_INT32, &loc2);	RTLU(SK_INT32, &loc3);	RTLU(SK_REF, &loc4);	RTLU(SK_REF, &loc5);		RTEAA(l_feature_name, 18, Current, 5, 1, 545);	RTSA(dtype);	RTSC;	RTME(dtype, 0);	RTGC;	RTDBGEAA(18, Current, 545);	RTCC(arg1, 18, l_feature_name, 1, eif_attached_type(218));	RTIV(Current, RTAL);	if ((RTAL & CK_REQUIRE) || RTAC) {		RTHOOK(1);		RTCT("valid_unencoded_string", EX_PRE);		ur1 = RTCCL(arg1);		tb1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(458, dtype))(Current, ur1x)).it_b);		RTTE(tb1, label_1);		RTCK;		RTJB;label_1:		RTCF;	}body:;	if (RTAL & CK_ENSURE) {		in_assertion = ~0;		RTE_OT		tr1 = arg1;		tr2 = NULL;		RTE_O		tr2 = RTLA;		RTE_OE		in_assertion = 0;	}	RTHOOK(2);	RTDBGAA(Current, dtype, 469, 0x04000000, 1); /* has_error */		*(EIF_BOOLEAN *)(Current + RTWA(469, dtype)) = (EIF_BOOLEAN) (EIF_BOOLEAN) 0;	RTHOOK(3);	RTDBGAL(Current, 5, 0xF80000DA, 0, 0); /* loc5 */		loc5 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(468, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	RTHOOK(4);	RTDBGAL(Current, 2, 0x10000000, 1, 0); /* loc2 */		ti4_1 = *(EIF_INTEGER_32 *)(arg1 + RTVA(3756, "count", arg1));	loc2 = (EIF_INTEGER_32) ti4_1;	RTHOOK(5);	RTDBGAL(Current, 1, 0x10000000, 1, 0); /* loc1 */		loc1 = (EIF_INTEGER_32) (EIF_INTEGER_32) ((EIF_INTEGER_32) (((EIF_INTEGER_32) 8L) * loc2) % ((EIF_INTEGER_32) 6L));	RTHOOK(6);	if ((EIF_BOOLEAN) (loc1 > ((EIF_INTEGER_32) 0L))) {		RTHOOK(7);		RTDBGAL(Current, 4, 0xF80002AA, 0, 0); /* loc4 */				ub1 = (EIF_BOOLEAN) 0;		ui4_1 = (EIF_INTEGER_32) ((EIF_INTEGER_32) (((EIF_INTEGER_32) 8L) * loc2) + (EIF_INTEGER_32) (((EIF_INTEGER_32) 6L) - loc1));		{			static EIF_TYPE_INDEX typarr0[] = {682,202,0xFFFF};			EIF_TYPE_INDEX typres0;			static EIF_TYPE_INDEX typcache0 = INVALID_DTYPE;						typres0 = (typcache0 != INVALID_DTYPE ? typcache0 : (typcache0 = eif_compound_id(dftype, typarr0)));			if (ui4_1< 0) {				eraise ("non_negative_argument", EN_RT_CHECK);			}			tr3 = RTLNSP2(eif_non_attached_type(typres0),0,ui4_1,sizeof(EIF_BOOLEAN), EIF_TRUE);		}		(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(2474, Dtype(tr3)))(tr3, ub1x, ui4_1x);		RTNHOOK(7,1);		loc4 = (EIF_REFERENCE) tr3;	} else {

 /**  * @brief Returns the scalar loss associated with a top blob at a given index.  */ inline Dtype loss(const int top_index) const {   return (loss_.size() > top_index) ? loss_[top_index] : Dtype(0); }

 /**  * @brief Sets the loss associated with a top blob at a given index.  */ inline void set_loss(const int top_index, const Dtype value) {   if (loss_.size() <= top_index) {     loss_.resize(top_index + 1, Dtype(0));   }   loss_[top_index] = value; }

/* {EV_WINDOW_IMP}.maximum_height */EIF_INTEGER_32 F1123_15412 (EIF_REFERENCE Current){	return *(EIF_INTEGER_32 *)(Current + O11959[Dtype(Current) - 1122]);}

void PoolingLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,      const vector<bool>& propagate_down, vector<Blob<Dtype>*>* bottom) {  if (!propagate_down[0]) {    return;  }  const Dtype* top_diff = top[0]->cpu_diff();  Dtype* bottom_diff = (*bottom)[0]->mutable_cpu_diff();  // Different pooling methods. We explicitly do the switch outside the for  // loop to save time, although this results in more codes.  caffe_set((*bottom)[0]->count(), Dtype(0), bottom_diff);  // We'll output the mask to top[1] if it's of size >1.  const bool use_top_mask = top.size() > 1;  const int* mask = NULL;  // suppress warnings about uninitialized variables  const Dtype* top_mask = NULL;  switch (this->layer_param_.pooling_param().pool()) {  case PoolingParameter_PoolMethod_MAX:    // The main loop    if (use_top_mask) {      top_mask = top[1]->cpu_data();    } else {      mask = max_idx_->cpu_data();    }    for (int n = 0; n < top[0]->num(); ++n) {      for (int c = 0; c < channels_; ++c) {        for (int ph = 0; ph < pooled_height_; ++ph) {          for (int pw = 0; pw < pooled_width_; ++pw) {            const int index = ph * pooled_width_ + pw;            const int bottom_index =                use_top_mask ? top_mask[index] : mask[index];            bottom_diff[bottom_index] += top_diff[index];          }        }        bottom_diff += (*bottom)[0]->offset(0, 1);        top_diff += top[0]->offset(0, 1);        if (use_top_mask) {          top_mask += top[0]->offset(0, 1);        } else {          mask += top[0]->offset(0, 1);        }      }    }    break;  case PoolingParameter_PoolMethod_AVE:    // The main loop    for (int n = 0; n < top[0]->num(); ++n) {      for (int c = 0; c < channels_; ++c) {        for (int ph = 0; ph < pooled_height_; ++ph) {          for (int pw = 0; pw < pooled_width_; ++pw) {            int hstart = ph * stride_ - pad_;            int wstart = pw * stride_ - pad_;            int hend = min(hstart + kernel_size_, height_ + pad_);            int wend = min(wstart + kernel_size_, width_ + pad_);            int pool_size = (hend - hstart) * (wend - wstart);            hstart = max(hstart, 0);            wstart = max(wstart, 0);            hend = min(hend, height_);            wend = min(wend, width_);            for (int h = hstart; h < hend; ++h) {              for (int w = wstart; w < wend; ++w) {                bottom_diff[h * width_ + w] +=                  top_diff[ph * pooled_width_ + pw] / pool_size;              }            }          }        }        // offset        bottom_diff += (*bottom)[0]->offset(0, 1);        top_diff += top[0]->offset(0, 1);      }    }    break;  case PoolingParameter_PoolMethod_STOCHASTIC:    NOT_IMPLEMENTED;    break;  default:    LOG(FATAL) << "Unknown pooling method.";  }}

/* {ES_SUITE}.add_test */void F891_7225 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x){	GTCX	char *l_feature_name = "add_test";	RTEX;	EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;#define arg1 arg1x.it_r	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE up2x = {{0}, SK_POINTER};#define up2 up2x.it_p	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE tr2 = NULL;	RTCFDT;	RTCDT;	RTSN;	RTDA;	RTLD;			RTLI(6);	RTLR(0,arg1);	RTLR(1,Current);	RTLR(2,tr1);	RTLR(3,tr2);	RTLR(4,loc1);	RTLR(5,ur1);	RTLU (SK_VOID, NULL);	RTLU(SK_REF,&arg1);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);		RTEAA(l_feature_name, 890, Current, 1, 1, 12838);	RTSA(dtype);	RTSC;	RTME(dtype, 0);	RTGC;	RTDBGEAA(890, Current, 12838);	RTCC(arg1, 890, l_feature_name, 1, eif_attached_type(892));	RTIV(Current, RTAL);	if ((RTAL & CK_REQUIRE) || RTAC) {		RTHOOK(1);		RTCT("unit_tests_class_exists", EX_PRE);		RTTE((EIF_BOOLEAN)(arg1 != NULL), label_1);		RTCK;		RTJB;label_1:		RTCF;	}body:;	RTHOOK(2);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(5135, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	if ((EIF_BOOLEAN)(tr1 == NULL)) {		RTHOOK(3);		RTDBGAA(Current, dtype, 5135, 0xF8000169, 0); /* classes */				tr1 = RTLNSMART(eif_non_attached_type(RTWCT(5135, dtype, dftype)));		(FUNCTION_CAST(void, (EIF_REFERENCE)) RTWC(2540, Dtype(tr1)))(tr1);		RTNHOOK(3,1);		RTAR(Current, tr1);		*(EIF_REFERENCE *)(Current + RTWA(5135, dtype)) = (EIF_REFERENCE) RTCCL(tr1);		RTHOOK(4);		RTDBGAA(Current, dtype, 5134, 0xF80000DB, 0); /* name */				tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(8, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTNHOOK(4,1);		tr2 = ((up2x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(3527, "name", tr1))(tr1)), (((up2x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up2x.it_r = RTBU(up2x))), (up2x.type = SK_POINTER), up2x.it_r);		RTNHOOK(4,2);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(17, "twin", tr2))(tr2)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTNHOOK(4,3);		tr2 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(4381, "as_string_8", tr1))(tr1)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTAR(Current, tr2);		*(EIF_REFERENCE *)(Current + RTWA(5134, dtype)) = (EIF_REFERENCE) RTCCL(tr2);	}

Dtype PoolingLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,      vector<Blob<Dtype>*>* top) {  const Dtype* bottom_data = bottom[0]->cpu_data();  Dtype* top_data = (*top)[0]->mutable_cpu_data();  const int top_count = (*top)[0]->count();  // We'll output the mask to top[1] if it's of size >1.  const bool use_top_mask = top->size() > 1;  int* mask = NULL;  // suppress warnings about uninitalized variables  Dtype* top_mask = NULL;  // Different pooling methods. We explicitly do the switch outside the for  // loop to save time, although this results in more code.  switch (this->layer_param_.pooling_param().pool()) {  case PoolingParameter_PoolMethod_MAX:    // Initialize    if (use_top_mask) {      top_mask = (*top)[1]->mutable_cpu_data();      caffe_set(top_count, Dtype(-1), top_mask);    } else {      mask = max_idx_->mutable_cpu_data();      caffe_set(top_count, -1, mask);    }    caffe_set(top_count, Dtype(-FLT_MAX), top_data);    // The main loop    for (int n = 0; n < bottom[0]->num(); ++n) {      for (int c = 0; c < channels_; ++c) {        for (int ph = 0; ph < pooled_height_; ++ph) {          for (int pw = 0; pw < pooled_width_; ++pw) {            int hstart = ph * stride_ - pad_;            int wstart = pw * stride_ - pad_;            int hend = min(hstart + kernel_size_, height_);            int wend = min(wstart + kernel_size_, width_);            hstart = max(hstart, 0);            wstart = max(wstart, 0);            const int pool_index = ph * pooled_width_ + pw;            for (int h = hstart; h < hend; ++h) {              for (int w = wstart; w < wend; ++w) {                const int index = h * width_ + w;                if (bottom_data[index] > top_data[pool_index]) {                  top_data[pool_index] = bottom_data[index];                  if (use_top_mask) {                    top_mask[pool_index] = static_cast<Dtype>(index);                  } else {                    mask[pool_index] = index;                  }                }              }            }          }        }        // compute offset        bottom_data += bottom[0]->offset(0, 1);        top_data += (*top)[0]->offset(0, 1);        if (use_top_mask) {          top_mask += (*top)[0]->offset(0, 1);        } else {          mask += (*top)[0]->offset(0, 1);        }      }    }    break;  case PoolingParameter_PoolMethod_AVE:    for (int i = 0; i < top_count; ++i) {      top_data[i] = 0;    }    // The main loop    for (int n = 0; n < bottom[0]->num(); ++n) {      for (int c = 0; c < channels_; ++c) {        for (int ph = 0; ph < pooled_height_; ++ph) {          for (int pw = 0; pw < pooled_width_; ++pw) {            int hstart = ph * stride_ - pad_;            int wstart = pw * stride_ - pad_;            int hend = min(hstart + kernel_size_, height_ + pad_);            int wend = min(wstart + kernel_size_, width_ + pad_);            int pool_size = (hend - hstart) * (wend - wstart);            hstart = max(hstart, 0);            wstart = max(wstart, 0);            hend = min(hend, height_);            wend = min(wend, width_);            for (int h = hstart; h < hend; ++h) {              for (int w = wstart; w < wend; ++w) {                top_data[ph * pooled_width_ + pw] +=                    bottom_data[h * width_ + w];              }            }            top_data[ph * pooled_width_ + pw] /= pool_size;          }        }        // compute offset        bottom_data += bottom[0]->offset(0, 1);        top_data += (*top)[0]->offset(0, 1);      }    }    break;  case PoolingParameter_PoolMethod_STOCHASTIC:    NOT_IMPLEMENTED;    break;  default:    LOG(FATAL) << "Unknown pooling method.";  }  return Dtype(0.);//.........这里部分代码省略.........

/* {TO_SPECIAL}.make_filled_area */void F431_2907 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x, EIF_TYPED_VALUE arg2x){	GTCX	char *l_feature_name = "make_filled_area";	RTEX;#define arg1 arg1x.it_r4#define arg2 arg2x.it_i4	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ur4_1x = {{0}, SK_REAL32};#define ur4_1 ur4_1x.it_r4	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};#define ui4_2 ui4_2x.it_i4	EIF_REFERENCE tr1 = NULL;	EIF_INTEGER_32 ti4_1;	EIF_BOOLEAN tb1;	RTCDT;	RTSN;	RTDA;	RTLD;		if ((arg2x.type & SK_HEAD) == SK_REF) arg2x.it_i4 = * (EIF_INTEGER_32 *) arg2x.it_r;	if ((arg1x.type & SK_HEAD) == SK_REF) arg1x.it_r4 = * (EIF_REAL_32 *) arg1x.it_r;		RTLI(2);	RTLR(0,Current);	RTLR(1,tr1);	RTLU (SK_VOID, NULL);	RTLU(SK_REAL32,&arg1);	RTLU(SK_INT32,&arg2);	RTLU (SK_REF, &Current);		RTEAA(l_feature_name, 430, Current, 0, 2, 3385);	RTSA(dtype);	RTSC;	RTME(dtype, 0);	RTGC;	RTDBGEAA(430, Current, 3385);	RTIV(Current, RTAL);	if ((RTAL & CK_REQUIRE) || RTAC) {		RTHOOK(1);		RTCT("non_negative_argument", EX_PRE);		RTTE((EIF_BOOLEAN) (arg2 >= ((EIF_INTEGER_32) 0L)), label_1);		RTCK;		RTJB;label_1:		RTCF;	}body:;	RTHOOK(2);	RTDBGAA(Current, dtype, 2426, 0xF80001AF, 0); /* area */		ur4_1 = arg1;	ui4_1 = arg2;	if (ui4_1< 0) {		eraise ("non_negative_argument", EN_RT_CHECK);	}	tr1 = RTLNSP2(eif_non_attached_type(RTWCT(2426, dtype, Dftype(Current))),0,ui4_1,sizeof(EIF_REAL_32), EIF_TRUE);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTWC(2590, Dtype(tr1)))(tr1, ur4_1x, ui4_1x);	RTNHOOK(2,1);	RTAR(Current, tr1);	*(EIF_REFERENCE *)(Current + RTWA(2426, dtype)) = (EIF_REFERENCE) tr1;	if (RTAL & CK_ENSURE) {		RTHOOK(3);		RTCT("area_allocated", EX_POST);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		if ((EIF_BOOLEAN)(tr1 != NULL)) {			RTCK;		} else {			RTCF;		}		RTHOOK(4);		RTCT("capacity_set", EX_POST);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTNHOOK(4,1);		ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2494, "capacity", tr1))(tr1)).it_i4);		if ((EIF_BOOLEAN)(ti4_1 == arg2)) {			RTCK;		} else {			RTCF;		}		RTHOOK(5);		RTCT("count_set", EX_POST);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTNHOOK(5,1);		ti4_1 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2493, "count", tr1))(tr1)).it_i4);		if ((EIF_BOOLEAN)(ti4_1 == arg2)) {			RTCK;		} else {			RTCF;		}		RTHOOK(6);		RTCT("area_filled", EX_POST);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(2426, dtype))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		RTNHOOK(6,1);		ur4_1 = arg1;		ui4_1 = ((EIF_INTEGER_32) 0L);//.........这里部分代码省略.........

void MultinomialLogisticLossMaskLayer<Dtype>::Backward_cpu(    const vector<Blob<Dtype>*>& top, const vector<bool>& propagate_down,    const vector<Blob<Dtype>*>& bottom) {  if (propagate_down[1]) {    LOG(FATAL) << this->type()               << " Layer cannot backpropagate to label inputs.";  }  const Dtype* bottom_data = bottom[0]->cpu_data();  const Dtype* bottom_label = bottom[1]->cpu_data();  const Dtype* bottom_mask = bottom[2]->cpu_data();  Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();  Dtype* mask_diff = bottom[2]->mutable_cpu_diff();  int dim = bottom[0]->count() / outer_num_;  caffe_set(bottom[0]->count(), Dtype(0), bottom_diff);  caffe_set(bottom[2]->count(), Dtype(0), mask_diff);      if (propagate_down[0]) {    int count = 0;    for (int i = 0; i < outer_num_; ++i) {      for (int j = 0; j < inner_num_; j++) {        const int label_value = static_cast<int>(bottom_label[i * inner_num_ + j]);        if (has_ignore_label_ && label_value == ignore_label_) {                continue;        }        Dtype p = std::max(          bottom_data[i * dim + label_value * inner_num_ + j]          , Dtype(kLOG_THRESHOLD));          bottom_diff[i * dim + label_value * inner_num_ + j] = Dtype(1.0) / p;        ++count;      }    }    Dtype scale = - top[0]->cpu_diff()[0] / (std::max(Dtype(1.0), Dtype(count)));    caffe_scal(bottom[0]->count(), scale, bottom_diff);  }  if (propagate_down[2]) {    int count = 0;    for (int i = 0; i < outer_num_; ++i) {      for (int j = 0; j < inner_num_; j++) {        const int label_value = static_cast<int>(bottom_label[i * inner_num_ + j]);        if (has_ignore_label_ && label_value == ignore_label_) {                continue;        }        Dtype m = std::max(          bottom_mask[i * inner_num_+ j]          , Dtype(kLOG_THRESHOLD));          if (label_value != 0){          mask_diff[i * inner_num_ + j] = Dtype(1.0) / m;        }        else{          mask_diff[i * inner_num_ + j] = Dtype(1.0) / (m-1);        }        ++count;      }    }    Dtype scale = - top[0]->cpu_diff()[0] / (std::max(Dtype(1.0), Dtype(count)));    caffe_scal(bottom[2]->count(), scale, mask_diff);  }}

/* {EXCEPTION}.message */EIF_TYPED_VALUE F90_1558 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "message";	RTEX;	EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ui4_1x = {{0}, SK_INT32};#define ui4_1 ui4_1x.it_i4	EIF_TYPED_VALUE ui4_2x = {{0}, SK_INT32};#define ui4_2 ui4_2x.it_i4	EIF_REFERENCE tr1 = NULL;	EIF_INTEGER_32 ti4_1;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		RTLI(4);	RTLR(0,loc1);	RTLR(1,Current);	RTLR(2,tr1);	RTLR(3,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);		RTEAA(l_feature_name, 89, Current, 1, 0, 1494);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(89, Current, 1494);	RTIV(Current, RTAL);	RTHOOK(1);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1453, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	loc1 = RTCCL(tr1);	if (EIF_TEST(loc1)) {		RTHOOK(2);		RTDBGAL(Current, 0, 0xF8000101, 0,0); /* Result */				ui4_1 = ((EIF_INTEGER_32) 1L);		ti4_1 = *(EIF_INTEGER_32 *)(loc1 + RTVA(1811, "count", loc1));		ui4_2 = ti4_1;		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE, EIF_TYPED_VALUE)) RTVF(1800, "substring", loc1))(loc1, ui4_1x, ui4_2x)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		Result = (EIF_REFERENCE) RTCCL(tr1);	}	RTVI(Current, RTAL);	RTRS;	RTHOOK(3);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(3);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef up1#undef ui4_1#undef ui4_2}

/* {MISMATCH_CORRECTOR}.correct_mismatch */void F116_2287 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "correct_mismatch";	RTEX;	EIF_REFERENCE loc1 = (EIF_REFERENCE) 0;	EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE up2x = {{0}, SK_POINTER};#define up2 up2x.it_p	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE tr2 = NULL;	RTSN;	RTDA;	RTLD;		RTLI(6);	RTLR(0,loc1);	RTLR(1,tr1);	RTLR(2,tr2);	RTLR(3,ur1);	RTLR(4,loc2);	RTLR(5,Current);	RTLU (SK_VOID, NULL);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);	RTLU(SK_REF, &loc2);		RTEAA(l_feature_name, 115, Current, 2, 0, 4828);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(115, Current, 4828);	RTIV(Current, RTAL);	RTHOOK(1);	RTDBGAL(Current, 1, 0xF80000AA, 0, 0); /* loc1 */		tr1 = RTLN(170);	tr2 = RTMS_EX_H("Mismatch: ",10,1538098208);	ur1 = tr2;	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWC(2970, Dtype(tr1)))(tr1, ur1x);	RTNHOOK(1,1);	loc1 = (EIF_REFERENCE) RTCCL(tr1);	RTHOOK(2);	RTDBGAL(Current, 2, 0xF800002A, 0, 0); /* loc2 */		tr1 = RTLN(42);	(FUNCTION_CAST(void, (EIF_REFERENCE)) RTWC(32, Dtype(tr1)))(tr1);	RTNHOOK(2,1);	loc2 = (EIF_REFERENCE) RTCCL(tr1);	RTHOOK(3);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(8, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	tr2 = ((up2x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(2057, "to_string_8", tr1))(tr1)), (((up2x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up2x.it_r = RTBU(up2x))), (up2x.type = SK_POINTER), up2x.it_r);	ur1 = RTCCL(tr2);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(3098, "append", loc1))(loc1, ur1x);	RTHOOK(4);	ur1 = RTCCL(loc1);	(FUNCTION_CAST(void, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(787, "raise_retrieval_exception", loc2))(loc2, ur1x);	RTVI(Current, RTAL);	RTRS;	RTHOOK(5);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(4);	RTEE;#undef up1#undef up2#undef ur1}

/* {EXCEPTION}.trace */EIF_TYPED_VALUE F90_1561 (EIF_REFERENCE Current){	GTCX	char *l_feature_name = "trace";	RTEX;	struct eif_ex_33 sloc1;	EIF_REFERENCE loc1 = (EIF_REFERENCE) sloc1.data;	EIF_REFERENCE loc2 = (EIF_REFERENCE) 0;	EIF_TYPED_VALUE up1x = {{0}, SK_POINTER};#define up1 up1x.it_p	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_REFERENCE tr1 = NULL;	EIF_REFERENCE Result = ((EIF_REFERENCE) 0);		RTSN;	RTDA;	RTLD;		memset (&sloc1.overhead, 0, OVERHEAD + 0);	sloc1.overhead.ov_flags = EO_EXP | EO_STACK;	RT_DFS(&sloc1.overhead, 33);	RTLI(6);	RTLR(0,loc2);	RTLR(1,Current);	RTLR(2,tr1);	RTLR(3,loc1);	RTLR(4,ur1);	RTLR(5,Result);	RTLU (SK_REF, &Result);	RTLU (SK_REF, &Current);	RTLU(SK_REF, &loc1);	RTLU(SK_REF, &loc2);		RTEAA(l_feature_name, 89, Current, 2, 0, 1497);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(89, Current, 1497);	RTIV(Current, RTAL);	wstdinit(loc1,loc1);	RTLXI(loc1);	RTHOOK(1);	tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTWF(1457, Dtype(Current)))(Current)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);	loc2 = RTCCL(tr1);	if (EIF_TEST(loc2)) {		RTHOOK(2);		RTDBGAL(Current, 0, 0xF8000107, 0,0); /* Result */				ur1 = RTCCL(loc2);		tr1 = ((up1x = (FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTVF(559, "utf_8_string_8_to_string_32", loc1))(loc1, ur1x)), (((up1x.type & SK_HEAD) == SK_REF)? (EIF_REFERENCE) 0: (up1x.it_r = RTBU(up1x))), (up1x.type = SK_POINTER), up1x.it_r);		Result = (EIF_REFERENCE) RTCCL(tr1);	}	RTVI(Current, RTAL);	RTRS;	RTHOOK(3);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(4);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_REF; r.it_r = Result; return r; }#undef up1#undef ur1}

/* {BASE64}.valid_encoded_string */EIF_TYPED_VALUE F19_462 (EIF_REFERENCE Current, EIF_TYPED_VALUE arg1x){	GTCX	char *l_feature_name = "valid_encoded_string";	RTEX;#define arg1 arg1x.it_r	EIF_TYPED_VALUE ur1x = {{0}, SK_REF};#define ur1 ur1x.it_r	EIF_INTEGER_32 ti4_1;	EIF_BOOLEAN tb1;	EIF_BOOLEAN tb2;	EIF_BOOLEAN tb3;	EIF_BOOLEAN Result = ((EIF_BOOLEAN) 0);		RTSN;	RTDA;	RTLD;			RTLI(3);	RTLR(0,arg1);	RTLR(1,ur1);	RTLR(2,Current);	RTLU (SK_BOOL, &Result);	RTLU(SK_REF,&arg1);	RTLU (SK_REF, &Current);		RTEAA(l_feature_name, 18, Current, 0, 1, 544);	RTSA(Dtype(Current));	RTSC;	RTME(Dtype(Current), 0);	RTGC;	RTDBGEAA(18, Current, 544);	RTCC(arg1, 18, l_feature_name, 1, eif_attached_type(218));	RTIV(Current, RTAL);	RTHOOK(1);	RTDBGAL(Current, 0, 0x04000000, 1,0); /* Result */		tb1 = '/0';	ur1 = RTCCL(arg1);	tb2 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE, EIF_TYPED_VALUE)) RTWF(459, 365))(Current, ur1x)).it_b);	if (tb2) {		tb2 = '/01';		tb3 = (((FUNCTION_CAST(EIF_TYPED_VALUE, (EIF_REFERENCE)) RTVF(3613, "is_empty", arg1))(arg1)).it_b);		if (!tb3) {			ti4_1 = *(EIF_INTEGER_32 *)(arg1 + RTVA(3756, "count", arg1));			tb2 = (EIF_BOOLEAN) (ti4_1 >= ((EIF_INTEGER_32) 4L));		}		tb1 = tb2;	}	Result = (EIF_BOOLEAN) tb1;	RTVI(Current, RTAL);	RTRS;	RTHOOK(2);	RTDBGLE;	RTMD(0);	RTLE;	RTLO(3);	RTEE;	{ EIF_TYPED_VALUE r; r.type = SK_BOOL; r.it_b = Result; return r; }#undef ur1#undef arg1}

void SparseDepthMahalanobisLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  for (int i = 0; i < 2; ++i) {    if (propagate_down[i]) {      const Dtype sign = (i == 0) ? 1 : -1;      const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();      if (bottom.size() >= 3) {        caffe_cpu_axpby(            bottom[i]->count(),              // count            alpha,                           // alpha            UtUdiff_.cpu_data(),             // a            Dtype(0),                        // beta            bottom[i]->mutable_cpu_diff());  // b      } else {        caffe_cpu_axpby(            bottom[i]->count(),              // count            alpha,                           // alpha            diff_.cpu_data(),                // a            Dtype(0),                        // beta            bottom[i]->mutable_cpu_diff());  // b      }    }  }  if (bottom.size() >= 3 && propagate_down[2])   {    const Dtype alpha = top[0]->cpu_diff()[0]/bottom[0]->num();    int num = bottom[0]->num();    int height = bottom[0]->height();    int width = bottom[0]->width();    int spatial_count = height*width;    const Dtype* label = bottom[1]->cpu_data();    for (int n = 0; n < num; ++n)    {       for (int h = 0; h < height; ++h)       {          for (int w = 0; w < width; ++w)          {              int offset = n*spatial_count + h*width + w;	      Dtype d_loss = alpha*Udiff_.cpu_data()[offset]*diff_.cpu_data()[offset]; // the contribution from the loss 	      Dtype mask = *(label + bottom[1]->offset(n,0,h,w));                            // the diagonal elements contribute to the regularizer and have an abs              // non linearity              Dtype d_reg = top[0]->cpu_diff()[0] / bottom[0]->num();              d_reg *= Dtype(-1) / (fabs(bottom[2]->cpu_data()[offset]) + Dtype(EPS));              if (bottom[2]->cpu_data()[offset] < 0)               {                 d_loss *= -1;                 d_reg *= -1;              }	      if (mask == Dtype(MASK_VAL))	      { 		  bottom[2]->mutable_cpu_diff()[offset] = Dtype(0);	      }              else bottom[2]->mutable_cpu_diff()[offset] = d_loss + d_reg;                          } // for w         } // for h    } // for n  } // if (bottom.size() >=3 ... }

/* {NATURAL_16_REF}.to_natural_16 */EIF_NATURAL_16 F870_9320 (EIF_REFERENCE Current){	GTCX			return (EIF_NATURAL_16) *(EIF_NATURAL_16 *)(Current+ _I16OFF_0_0_0_);}/* {NATURAL_16_REF}.to_natural_32 */EIF_NATURAL_32 F870_9321 (EIF_REFERENCE Current){	GTCX			return (EIF_NATURAL_32) (FUNCTION_CAST(EIF_NATURAL_32, (EIF_REFERENCE)) R7462[Dtype(Current)-869])(Current);}/* {NATURAL_16_REF}.to_natural_64 */EIF_NATURAL_64 F870_9322 (EIF_REFERENCE Current){	GTCX			return (EIF_NATURAL_64) (FUNCTION_CAST(EIF_NATURAL_64, (EIF_REFERENCE)) R7463[Dtype(Current)-869])(Current);}/* {NATURAL_16_REF}.to_integer_32 */EIF_INTEGER_32 F870_9325 (EIF_REFERENCE Current){	GTCX