var (
	flagBuildid = flag.String("buildid", "", "record `id` as Go toolchain build id")
	flagBindNow = flag.Bool("bindnow", false, "mark a dynamically linked ELF object for immediate function binding")

	flagOutfile    = flag.String("o", "", "write output to `file`")
	flagPluginPath = flag.String("pluginpath", "", "full path name for plugin")

		if partsMetadata[i].IsRemote() {
			rmDataDir := partsMetadata[i].DataDir
			disk.Delete(ctx, bucket, pathJoin(encodeDirObject(object), rmDataDir), DeleteOptions{
				Immediate: true,
				Recursive: true,
			})
		}

		for i, v := range result.Before.Drives {
			if v.Endpoint == disk.String() {
				result.After.Drives[i].State = madmin.DriveStateOk
			}
		}
	}

				}
			}
		case "r":
			z.Recursive, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Recursive")
				return
			}
		case "i":
			z.Immediate, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Immediate")
				return
			}
		case "u":
			z.UndoWrite, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "UndoWrite")
				return
			}

	namespace := pvc.Namespace
	pvcName := pvc.Name
	scName := storagehelpers.GetPersistentVolumeClaimClass(pvc)

	// If StorageClass is not set or not found, then PVC must be using immediate binding mode
	// and hence it must be bound before scheduling. So it is safe to not count it.
	if scName == "" {
		logger.V(5).Info("PVC has no StorageClass", "PVC", klog.KObj(pvc))
		return "", ""
	}

				// DRA driver controller in the control plane
				// needs to do the deallocation.
				claim.Status.DeallocationRequested = true
			}
			// In all other cases, we keep the claim allocated, in particular for immediate allocation
			// with a control plane controller.
		}

		claim, err := ec.kubeClient.ResourceV1alpha2().ResourceClaims(claim.Namespace).UpdateStatus(ctx, claim, metav1.UpdateOptions{})
		if err != nil {

// (See comment in go/types.identical, case *Interface, for more.)
func (h Hasher) shallowHash(t types.Type) uint32 {
	// t is the type of an interface method (Signature),
	// its params or results (Tuples), or their immediate
	// elements (mostly Slice, Pointer, Basic, Named),
	// so there's no need to optimize anything else.
	switch t := t.(type) {
	case *aliases.Alias:
		return h.shallowHash(aliases.Unalias(t))

				return err
			}
		}
		if cb != nil {
			cb(resource.Name, claim)
		}
	}
	return nil
}

// PreFilter invoked at the prefilter extension point to check if pod has all
// immediate claims bound. UnschedulableAndUnresolvable is returned if
// the pod cannot be scheduled at the moment on any node.

	freeBlocks *Block // free Blocks linked by succstorage[0].b.  All other fields except ID are 0/nil.

	cachedPostorder  []*Block   // cached postorder traversal
	cachedIdom       []*Block   // cached immediate dominators
	cachedSdom       SparseTree // cached dominator tree
	cachedLoopnest   *loopnest  // cached loop nest information
	cachedLineStarts *xposmap   // cached map/set of xpos to integers

  // ImmutableMap.Builder, so that it can remember any DuplicateKey encountered and produce an
  // exception for a later buildOrThrow(). If builder is null that means that a duplicate
  // key will lead to an immediate exception. If it is not null then a duplicate key will instead be
  // stored in the builder, which may use it to throw an exception later.
  static <K, V> RegularImmutableMap<K, V> create(

There is a somewhat non-obvious filter present on the page that allows you to control which type of messages are displayed.
The filter is a dropdown box that appears when you click the `Severity ⬇️ ` label in the black header bar to the immediate right of the Gradle version.

If you have a large number of messages of different types, filtering by severity to see only `Error`s can be helpful when processing the report.