for i := 0; i < len; i++ {
		// second return value is "more", not "ok"
		frame, _ := frames.Next()
		if (!strings.HasPrefix(frame.File, gormSourceDir) ||
			strings.HasSuffix(frame.File, "_test.go")) && !strings.HasSuffix(frame.File, ".gen.go") {
			return frame
		}
	}

	return runtime.Frame{}
}

// FileWithLineNum return the file name and line number of the current file
func FileWithLineNum() string {

	app.Action = func(c *cli.Context) error {
		if !c.Args().Present() {
			cli.ShowAppHelpAndExit(c, 1) // last argument is exit code
		}

		ht := make(map[string]map[string]any)
		file := c.Args().Get(0)
		if strings.HasSuffix(file, ".zip") {
			var sz int64
			f, err := os.Open(file)
			if err != nil {
				return err
			}
			if st, err := f.Stat(); err == nil {
				sz = st.Size()
			}
			defer f.Close()

	if len(args) != 1 || !strings.HasSuffix(args[0], ".zip") {
		usage()
	}

	var zb bytes.Buffer
	zw := zip.NewWriter(&zb)
	seen := make(map[string]bool)
	err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
		if d.IsDir() {
			return nil
		}
		data, err := os.ReadFile(path)
		if err != nil {
			log.Fatal(err)
		}
		if strings.HasSuffix(path, ".zip") {

}

func buildMinioPath(p string) string {
	return strings.TrimPrefix(p, SlashSeparator)
}

func buildMinioDir(p string) string {
	v := buildMinioPath(p)
	if !strings.HasSuffix(v, SlashSeparator) {
		return v + SlashSeparator
	}
	return v
}

type minioFileInfo struct {
	p     string
	info  minio.ObjectInfo
	isDir bool
}

func (m *minioFileInfo) Name() string {

// prefix, false otherwise.
func (v Versioning) PrefixEnabled(prefix string) bool {
	if v.Status != Enabled {
		return false
	}

	if prefix == "" {
		return true
	}
	if v.ExcludeFolders && strings.HasSuffix(prefix, "/") {
		return false
	}

	for _, sprefix := range v.ExcludedPrefixes {
		// Note: all excluded prefix patterns end with `/` (See Validate)
		sprefix.Prefix += "*"

			return ctx.Err()
		case out <- entry:
		}
		return nil
	}

	// Fast exit track to check if we are listing an object with
	// a trailing slash, this will avoid to list the object content.
	if HasSuffix(opts.BaseDir, SlashSeparator) {
		metadata, err := s.readMetadata(ctx, pathJoin(volumeDir,
			opts.BaseDir[:len(opts.BaseDir)-1]+globalDirSuffix,
			xlStorageFormatFile))
		diskHealthCheckOK(ctx, err)
		if err == nil {

}

func processFile(inputFileName string, privateKeys [][]byte) {
	// Calculate the output file name
	var outputFileName string
	switch {
	case strings.HasSuffix(inputFileName, ".enc"):
		outputFileName = strings.TrimSuffix(inputFileName, ".enc") + ".zip"
	case strings.HasSuffix(inputFileName, ".zip"):
		outputFileName = strings.TrimSuffix(inputFileName, ".zip") + ".decrypted.zip"
	case strings.Contains(inputFileName, ".enc."):

		// The general form of a test input line is:
		//	// comment
		//	INST args [// printed form] [// hex encoding]
		parts := strings.Split(line, "//")
		printed := strings.TrimSpace(parts[0])
		if printed == "" || strings.HasSuffix(printed, ":") { // empty or label
			continue
		}
		seq++

		var hexes string
		switch len(parts) {
		default:
			t.Errorf("%s:%d: unable to understand comments: %s", input, lineno, line)
		case 1:

	// Output:
	// true
	// false
	// true
}

func ExampleHasSuffix() {
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("go")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("O")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("Ami")))
	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("")))
	// Output:
	// true
	// false
	// false
	// true
}

func ExampleIndex() {

	count = 1
	v := strings.Split(k, ":")
	if len(v) == 2 {
		return strconv.Atoi(v[0])
	}
	return count, err
}

func parseKey(k string) (key Key) {
	key.Name = k
	if strings.HasSuffix(k, compressExt) {
		key.Compress = true
		key.Name = strings.TrimSuffix(key.Name, compressExt)
	}
	if key.ItemCount, _ = getItemCount(k); key.ItemCount > 1 {