本文整理汇总了C++中Dtype函数的典型用法代码示例。如果您正苦于以下问题：C++ Dtype函数的具体用法？C++ Dtype怎么用？C++ Dtype使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Dtype函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: F334_6432
/* {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
}示例2: F90_1559
/* {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
}示例3: F90_1570
/* {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);
//.........这里部分代码省略.........
示例4: caffe_set
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);
}
}示例5: caffe_sign
inline int8_t caffe_sign(Dtype val) {
return (Dtype(0) < val) - (val < Dtype(0));
}示例6: caffe_copy
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());
}示例7: F682_12810
/* {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
}示例8: F865_6949
/* {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
}示例9: CHECK_LE
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) {
//.........这里部分代码省略.........
示例10: caffe_cpu_gemm
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;
}示例11: F865_6951
/* {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;
//.........这里部分代码省略.........
示例12: caffe_set
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);
}示例13: caffe_sub
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;
}示例14: caffe_cpu_axpby
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]);
}
}
}
*/
}示例15: F19_463
//.........这里部分代码省略.........
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 {