Name:   "address",
		Value:  ":" + GlobalMinioDefaultPort,
		Usage:  "bind to a specific ADDRESS:PORT, ADDRESS can be an IP or hostname",
		EnvVar: "MINIO_ADDRESS",
	},
}

var fmtGenCmd = cli.Command{
	Name:   "fmt-gen",
	Usage:  "Generate format.json files for an erasure server pool",
	Flags:  append(fmtGenFlags, GlobalFlags...),
	Action: fmtGenMain,
	Hidden: true,
	CustomHelpTemplate: `NAME:
  {{.HelpName}} - {{.Usage}}

func (log *minioLogger) Print(sessionID string, message any) {
	if serverDebugLog {
		fmt.Printf("%s %s\n", sessionID, message)
	}
}

// Printf implement Logger
func (log *minioLogger) Printf(sessionID string, format string, v ...any) {
	if serverDebugLog {
		if sessionID != "" {
			fmt.Printf("%s %s\n", sessionID, fmt.Sprintf(format, v...))
		} else {
			fmt.Printf(format+"\n", v...)
		}
	}
}

// PrintCommand implement Logger

			}
			if errors.Is(err, estream.ErrNoKey) {
				fmt.Println("Skipping", stream.Name, "no private key")
				if err := stream.Skip(); err != nil {
					return fmt.Errorf("stream skip: %w", err)
				}
				continue
			}
			return fmt.Errorf("next stream: %w", err)
		}
		if strings.Contains(stream.Name, "..") || !utf8.ValidString(stream.Name) {
			return fmt.Errorf("invalid stream name: %q", stream.Name)
		}

		{"", Endpoint{}, -1, fmt.Errorf("empty or root endpoint is not supported")},
		{SlashSeparator, Endpoint{}, -1, fmt.Errorf("empty or root endpoint is not supported")},
		{`\`, Endpoint{}, -1, fmt.Errorf("empty or root endpoint is not supported")},
		{"c://foo", Endpoint{}, -1, fmt.Errorf("invalid URL endpoint format")},
		{"ftp://foo", Endpoint{}, -1, fmt.Errorf("invalid URL endpoint format")},

	if msg == "" {
		fmt.Fprintln(Output, args...)
	} else {
		fmt.Fprintf(Output, `INFO: `+msg, args...)
	}
}

type errorMsg struct{}

var errorMessage errorMsg

func (i errorMsg) json(msg string, args ...any) {
	var message string
	if msg != "" {
		message = fmt.Sprintf(msg, args...)
	} else {
		message = fmt.Sprint(args...)
	}

		}
		return fmt.Sprintf
	}()

	RedBold = func() func(a ...any) string {
		if IsTerminal() {
			return color.New(color.FgRed, color.Bold).SprintFunc()
		}
		return fmt.Sprint
	}()

	RedBoldf = func() func(format string, a ...any) string {
		if IsTerminal() {
			return color.New(color.FgRed, color.Bold).SprintfFunc()
		}
		return fmt.Sprintf
	}()

						fmt.Println("Remapped", partName, "to", fn)
					}
					delete(partDataToVerID, partName)
					err := os.WriteFile(fn, data, os.ModePerm)
					if err != nil {
						fmt.Println("WriteFile:", err)
					}
				}
			}
			if len(partDataToVerID) > 0 {
				fmt.Println("MISSING PART FILES:")
				for k := range partDataToVerID {
					fmt.Println(k)
				}
				fmt.Println("END MISSING PART FILES")
			}
		}

		drwm1.RUnlock(t.Context())
		// fmt.Println("1st read lock released, waiting...")
	}()

	go func() {
		time.Sleep(3 * testDrwMutexAcquireTimeout)
		drwm2.RUnlock(t.Context())
		// fmt.Println("2nd read lock released, waiting...")
	}()

	drwm3 := NewDRWMutex(ds, "simplelock")
	// fmt.Println("Trying to acquire write lock, waiting...")
	ctx3, cancel3 := context.WithCancel(t.Context())

	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {
		fmt.Println("ReadFrom Error:", err)
		return
	}

	if err = writer.Flush(); err != nil {
		fmt.Println("Flush Error:", err)
		return
	}

	fmt.Println("Bytes written:", n)
	fmt.Println("Buffer contents:", buf.String())
	// Output:
	// Bytes written: 41
	// Buffer contents: Hello, world!

func (m *muxClient) response(seq uint32, r Response) {
	if debugReqs {
		fmt.Println(m.MuxID, m.parent.String(), "RESP")
	}
	if debugPrint {
		fmt.Printf("mux %d: got msg seqid %d, payload length: %d, err:%v\n", m.MuxID, seq, len(r.Msg), r.Err)
	}
	if !m.checkSeq(seq) {
		if debugReqs {
			fmt.Println(m.MuxID, m.parent.String(), "CHECKSEQ FAIL", m.RecvSeq, seq)
		}
		PutByteBuffer(r.Msg)