// GetHumanSizeRepresentation returns the size in a human readable binary prefix of bytes format
541894
func (size Bits) GetHumanSizeRepresentation() string {
	// if size >= YiB {
	// 	return size.YiBString()
	// }
	// if size >= ZiB {
	// 	return size.ZiBString()
	// }
	if size >= EiB {
		return size.EiBString()
	}
	if size >= PiB {
		return size.PiBString()
	}
	if size >= TiB {
		return size.TiBString()
	}
	if size >= GiB {
		return size.GiBString()
	}
	if size >= MiB {
		return size.MiBString()
	}
	if size >= KiB {
		return size.KiBString()
	}
	return size.ByteString()
}
261358
func (r *RepositoryLicense) GetSize() int {
	if r == nil || r.Size == nil {
		return 0
	}
	return *r.Size
}
374262
func (co *Context) GetReductionIndicesSize(reduceTensorDesc *Reduction, aDesc *TensorDescriptor, cDesc *TensorDescriptor) (sizeInBytes uintptr, err error) {
	var sizeInBytesC C.size_t
	// call cudnnGetReductionIndicesSize
	err = result(C.cudnnGetReductionIndicesSize(co.internal, reduceTensorDesc.internal, aDesc.internal, cDesc.internal, &sizeInBytesC))
	sizeInBytes = uintptr(sizeInBytesC)
	return
}
127295
func GetOriginalConfiguration(info *resource.Info) ([]byte, error) {
	annotations, err := info.Mapping.MetadataAccessor.Annotations(info.Object)
	if err != nil {
		return nil, err
	}

	if annotations == nil {
		return nil, nil
	}

	original, ok := annotations[LastAppliedConfigAnnotation]
	if !ok {
		return nil, nil
	}

	return []byte(original), nil
}
827124
func GetRepoSize(repoPath string) (*CountObject, error) {
	cmd := NewCommand("count-objects", "-v")
	stdout, err := cmd.RunInDir(repoPath)
	if err != nil {
		return nil, err
	}

	countObject := new(CountObject)
	for _, line := range strings.Split(stdout, "\n") {
		switch {
		case strings.HasPrefix(line, _STAT_COUNT):
			countObject.Count = com.StrTo(line[7:]).MustInt64()
		case strings.HasPrefix(line, _STAT_SIZE):
			countObject.Size = com.StrTo(line[6:]).MustInt64() * 1024
		case strings.HasPrefix(line, _STAT_IN_PACK):
			countObject.InPack = com.StrTo(line[9:]).MustInt64()
		case strings.HasPrefix(line, _STAT_PACKS):
			countObject.Packs = com.StrTo(line[7:]).MustInt64()
		case strings.HasPrefix(line, _STAT_SIZE_PACK):
			countObject.SizePack = com.StrTo(line[11:]).MustInt64() * 1024
		case strings.HasPrefix(line, _STAT_PRUNE_PACKABLE):
			countObject.PrunePackable = com.StrTo(line[16:]).MustInt64()
		case strings.HasPrefix(line, _STAT_GARBAGE):
			countObject.Garbage = com.StrTo(line[9:]).MustInt64()
		case strings.HasPrefix(line, _STAT_SIZE_GARBAGE):
			countObject.SizeGarbage = com.StrTo(line[14:]).MustInt64() * 1024
		}
	}

	return countObject, nil
}
346271
func (c *Users) GetSpaceUsage() (out *GetSpaceUsageOutput, err error) {
	body, err := c.call("/users/get_space_usage", nil)
	if err != nil {
		return
	}
	defer body.Close()

	err = json.NewDecoder(body).Decode(&out)
	return
}
774696
func (_class VGPUTypeClass) GetMaxResolutionY(sessionID SessionRef, self VGPUTypeRef) (_retval int, _err error) {
	_method := "VGPU_type.get_max_resolution_y"
	_sessionIDArg, _err := convertSessionRefToXen(fmt.Sprintf("%s(%s)", _method, "session_id"), sessionID)
	if _err != nil {
		return
	}
	_selfArg, _err := convertVGPUTypeRefToXen(fmt.Sprintf("%s(%s)", _method, "self"), self)
	if _err != nil {
		return
	}
	_result, _err := _class.client.APICall(_method, _sessionIDArg, _selfArg)
	if _err != nil {
		return
	}
	_retval, _err = convertIntToGo(_method + " -> ", _result.Value)
	return
}
814549
func (c *ZebedeeClient) GetFileSize(uri string) (data.FileSize, error) {
	b, err := c.get("/filesize?uri=" + uri)
	if err != nil {
		return data.FileSize{}, err
	}

	var fs data.FileSize
	if err = json.Unmarshal(b, &fs); err != nil {
		return fs, err
	}

	return fs, nil
}
698894
func OptServerTranslateFileMapSize(mapSize int) ServerOption {
	return func(s *Server) error {
		s.holder.translateFile = NewTranslateFile(OptTranslateFileMapSize(mapSize))
		return nil
	}
}
328989
func getMaxHeaderTableSize(settings []http2.Setting) uint32 {
	for _, setting := range settings {
		if setting.ID == http2.SettingHeaderTableSize {
			return setting.Val
		}
	}
	return 4096
}
1282752
func (kinesis *Kinesis) GetShardIterator(args *RequestArgs) (resp *GetShardIteratorResp, err error) {
	params := makeParams("GetShardIterator")
	resp = &GetShardIteratorResp{}
	err = kinesis.query(params, args.params, resp)
	if err != nil {
		return nil, err
	}
	return
}
273230
func (v *Widget) GetSizeRequest() (width int, height int) {
	var w, h C.gint
	C.gtk_widget_get_size_request(v.GWidget, &w, &h)
	return int(w), int(h)
}
692469
func (r *RepositoryContent) GetSize() int {
	if r == nil || r.Size == nil {
		return 0
	}
	return *r.Size
}
750034
func (r Billing_Invoice) GetPdfFileSize() (resp int, err error) {
	err = r.Session.DoRequest("SoftLayer_Billing_Invoice", "getPdfFileSize", nil, &r.Options, &resp)
	return
}
1272967
func (s *UsersService) GetPresence(user string) *UsersGetPresenceCall {
	var call UsersGetPresenceCall
	call.service = s
	call.user = user
	return &call
}
591279
func (s *Server) GetServiceProvider(r *http.Request, serviceProviderID string) (*saml.EntityDescriptor, error) {
	s.idpConfigMu.RLock()
	defer s.idpConfigMu.RUnlock()
	rv, ok := s.serviceProviders[serviceProviderID]
	if !ok {
		return nil, os.ErrNotExist
	}
	return rv, nil
}
143476
func (j *jumpMap) jumpSizeIsOversized(c *compilerContext, fromJump int) bool {
	l := j.positionToLabel[fromJump]
	to := c.labels.positionOf(l)
	return (to-fromJump)-1 > c.maxJumpSize
}