deleteMarkerTotal MetricName = "deletemarker_total"
	offlineTotal      MetricName = "offline_total"
	onlineTotal       MetricName = "online_total"
	openTotal         MetricName = "open_total"
	readTotal         MetricName = "read_total"
	timestampTotal    MetricName = "timestamp_total"
	writeTotal        MetricName = "write_total"
	total             MetricName = "total"
	freeInodes        MetricName = "free_inodes"

		} else {
			atomic.AddUint64(&v.RmvTagFailedTotal, 1)
			atomic.AddUint64(&p.srProxyStats.RmvTagFailedTotal, 1)
		}
	case headObjectAPI:
		if !isErr {
			atomic.AddUint64(&v.HeadTotal, 1)
			atomic.AddUint64(&p.srProxyStats.HeadTotal, 1)
		} else {
			atomic.AddUint64(&v.HeadFailedTotal, 1)
			atomic.AddUint64(&p.srProxyStats.HeadFailedTotal, 1)
		}
	case getObjectAPI:
		if !isErr {

			}
		case "gc":
			z.GetTotal, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "GetTotal")
				return
			}
		case "hc":
			z.HeadTotal, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "HeadTotal")
				return
			}
		case "ptf":
			z.PutTagFailedTotal, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "PutTagFailedTotal")
				return

  builder.setInsertionPoint(op);
  auto padding_type = RankedTensorType::get({4, 2}, builder.getIntegerType(32));

  // Calculate paddings.
  int32_t pad_total = kernel_size - 1;
  int32_t pad_beg = (pad_total / 2 + 1) / block_size;
  int32_t pad_end = (pad_total / 2) / block_size;
  SmallVector<int32_t, 8> values = {0,       0,       pad_beg, pad_end,
                                    pad_beg, pad_end, 0,       0};

					m.Set(bucketReplProxiedHeadRequestsFailures, float64(s.ProxyStats.HeadFailedTotal), labels...)
					m.Set(bucketReplProxiedHeadRequestsTotal, float64(s.ProxyStats.HeadTotal), labels...)
					m.Set(bucketReplProxiedPutTaggingRequestsFailures, float64(s.ProxyStats.PutTagFailedTotal), labels...)
					m.Set(bucketReplProxiedPutTaggingRequestsTotal, float64(s.ProxyStats.PutTagTotal), labels...)

                                 : padding == tensorflow::Padding::SAME
                                     ? std::max<int64_t>(pad_total / 2, 0)
                                     : 0;
      paddings.push_back(pad_before);
      paddings.push_back(pad_total - pad_before);
    }

    RankedTensorType paddings_ty = tensorflow::GetTypeFromTFTensorShape(