time.Sleep(retryDelay250)
					retries++
					continue
				}
				break
			}
		}
		retryWait := func() {
			retries++
			if retries == 1 {
				time.Sleep(retryDelay)
			} else {
				time.Sleep(retryDelay250)
			}
		}
		// Load first part metadata...
		// Read metadata associated with the object from all disks.

				hdr.Linkname = gnuLongLink
			}
			if hdr.Typeflag == TypeRegA {
				if strings.HasSuffix(hdr.Name, "/") {
					hdr.Typeflag = TypeDir // Legacy archives use trailing slash for directories
				} else {
					hdr.Typeflag = TypeReg
				}
			}

			// The extended headers may have updated the size.
			// Thus, setup the regFileReader again after merging PAX headers.

				return
			}
			switch v := v.(type) {
			case expiryTask:
				if v.objInfo.TransitionedObject.Status != "" {
					applyExpiryOnTransitionedObject(es.ctx, es.objAPI, v.objInfo, v.event, v.src)
				} else {
					applyExpiryOnNonTransitionedObjects(es.ctx, es.objAPI, v.objInfo, v.event, v.src)
				}
			case noncurrentVersionsTask:
				deleteObjectVersions(es.ctx, es.objAPI, v.bucket, v.versions, v.events)
			case jentry:

		}
	}
	logIf(ctx, subsystem, err)
}

func errToEntry(ctx context.Context, subsystem string, err error, errKind ...any) log.Entry {
	var l string
	if anonFlag {
		l = reflect.TypeOf(err).String()
	} else {
		l = fmt.Sprintf("%v (%T)", err, err)
	}
	return buildLogEntry(ctx, subsystem, l, getTrace(3), errKind...)
}

func logToEntry(ctx context.Context, subsystem, message string, errKind ...any) log.Entry {

		Name:               fi.Name(),
		UncompressedSize64: uint64(size),
	}
	fh.SetModTime(fi.ModTime())
	fh.SetMode(fi.Mode())
	if fh.UncompressedSize64 > uint32max {
		fh.UncompressedSize = uint32max
	} else {
		fh.UncompressedSize = uint32(fh.UncompressedSize64)
	}
	return fh, nil
}

type directoryEnd struct {
	diskNbr            uint32 // unused
	dirDiskNbr         uint32 // unused

                        ),
                    ),
            ),
            Stage(
                StageName.HISTORICAL_PERFORMANCE,
                trigger = if (branch.isLegacyRelease) Trigger.NEVER else Trigger.WEEKLY,
                runsIndependent = true,
                performanceTests =
                    listOf(
                        PerformanceTestCoverage(
                            4,

      EXPECT_FALSE(found_placeholder);
      found_placeholder = true;
    } else if (oper == three) {
      EXPECT_FALSE(found_scalar_const);
      found_scalar_const = true;
    } else if (oper == add) {
      EXPECT_FALSE(found_add);
      found_add = true;
    } else if (oper == neg) {
      EXPECT_FALSE(found_neg);
      found_neg = true;
    } else {
      ASSERT_TRUE(GetNodeDef(oper, &node_def));

#*      *##set ( $spdx = 'Public-Domain' )
#*    *##elseif ( $license.name == "CDDL + GPLv2 with classpath exception" )
#*      *##set ( $spdx = 'CDDL+GPLv2-with-classpath-exception' )
#*    *##else
#*      *### unrecognized license will require analysis to know obligations
#*      *##set ( $spdx = $license )
#*    *##end
#*    *###
#*    *### fix project urls that are wrong in pom

            versioning.setSnapshot(snapshot);
            versioning.setLastUpdatedTimestamp(timestamp);
            lastUpdated = versioning.getLastUpdated();

            metadata.setVersioning(versioning);
        } else {
            snapshot = metadata.getVersioning().getSnapshot();
            lastUpdated = metadata.getVersioning().getLastUpdated();
        }

        for (Artifact artifact : artifacts) {

        boolean reverse = false;
        final boolean result;
        if (test.startsWith(REGEX_PREFIX)) {
            result = actualVersion.matches(test.substring(REGEX_PREFIX.length()));
        } else {
            if (test.startsWith("!")) {
                reverse = true;
                test = test.substring(1);
            }
            result = actualVersion.equalsIgnoreCase(test);
        }