return err
	}

	pt, err := time.Parse(RFC3339Micro, str)
	if err != nil {
		return err
	}

	t.Time = pt.Local()
	return nil
}

func (t *MicroTime) UnmarshalCBOR(b []byte) error {
	var s *string
	if err := cbor.Unmarshal(b, &s); err != nil {
		return err
	}
	if s == nil {
		t.Time = time.Time{}
		return nil
	}

	parsed, err := time.Parse(RFC3339Micro, *s)

		return err
	}

	pt, err := time.Parse(time.RFC3339, str)
	if err != nil {
		return err
	}

	t.Time = pt.Local()
	return nil
}

func (t *Time) UnmarshalCBOR(b []byte) error {
	var s *string
	if err := cbor.Unmarshal(b, &s); err != nil {
		return err
	}
	if s == nil {
		t.Time = time.Time{}
		return nil
	}

	parsed, err := time.Parse(time.RFC3339, *s)
	if err != nil {

import org.gradle.internal.serialize.graph.WriteContext


/**
 * This class exists because PublishArtifactLocalArtifactMetadata is used as its own id, and so when serialized as an id causes
 * a lot of unnecessary and unserializable state to be dragged in.
 *
 * A better change would be to split an immutable id type out of PublishArtifactLocalArtifactMetadata (or reuse one of the existing

 * * the differences in the source information, like source identifiers or the offsets in the source data,
 * * the source representations of the literal values (thus taking into account only the values),
 * * the error causes, thus considering all error nodes equal to each other but not to any other node.
 */
fun DeclarativeDocument.structurallyEqualsAsData(other: DeclarativeDocument): Boolean {

import org.gradle.launcher.exec.BuildActionExecutor;
import org.gradle.launcher.exec.BuildActionParameters;
import org.gradle.launcher.exec.BuildActionResult;

/**
 * Reports any unreported failure that causes the session to finish.
 */
public class SessionFailureReportingActionExecutor implements BuildActionExecutor<BuildActionParameters, BuildRequestContext> {

using ::tensorflow::quantization::PyFunctionLibrary;

// Note for maintainers: the definitions should ONLY mirror existing functions
// defined in different targets. Do not include any extra business logic that
// causes divergence from the semantics of mirrored functions.

absl::Status PywrapQuantizeStaticRangePtq(
    absl::string_view src_saved_model_path,
    absl::string_view dst_saved_model_path, const QuantizationConfig& config,

        shell: bash
        run: ./mvnw -B -P!standard-with-extra-repos verify -U -Dmaven.javadoc.skip=true -f $ROOT_POM
      - name: 'Print Surefire reports'
        # Note: Normally a step won't run if the job has failed, but this causes it to
        if: ${{ failure() }}
        shell: bash
        run: ./util/print_surefire_reports.sh
      - name: 'Integration Test'
        if: matrix.java == 11
        shell: bash

	// It is empty for the default K8S tokens.
	Aud []string `json:"aud"`
}

// ExtractJwtAud extracts the audiences from a JWT token. If aud cannot be parse, the bool will be set
// to false. This distinguishes aud=[] from not parsed.
func ExtractJwtAud(jwt string) ([]string, bool) {
	jwtSplit := strings.Split(jwt, ".")
	if len(jwtSplit) != 3 {
		return nil, false
	}
	payload := jwtSplit[1]

            we don't do this, we get 2.0b4, which is not present in our verification-metadata.xml file and causes a build failure.
        """.trimMargin())
    }

    implementation(projects.concurrent)

    implementation(libs.slf4jApi)

    testImplementation(testFixtures(project(":core")))

            } catch (FileNotFoundException e) {
                throw new FileException(e);
            }
        }
    }

    /**
     * {@link ZipFile} is more efficient, but causes memory leaks on older Java versions, so we only use it on more recent ones.
     */
    private static boolean isZipFileSafeToUse() {
        String versionString = System.getProperty("java.specification.version");