return errors.New("crypto/sha512: invalid hash state identifier")
	}
	switch {
	case d.function == crypto.SHA384 && string(b[:len(magic384)]) == magic384:
	case d.function == crypto.SHA512_224 && string(b[:len(magic512_224)]) == magic512_224:
	case d.function == crypto.SHA512_256 && string(b[:len(magic512_256)]) == magic512_256:
	case d.function == crypto.SHA512 && string(b[:len(magic512)]) == magic512:
	default:

  // Run TFRT initialization function to pre-instantiate fallback kernels.
  RunTfrtInitializer();
}

llvm::SmallVector<Tensor> RuntimeFallbackExecutor::Execute(
    llvm::StringRef function_name, llvm::ArrayRef<Tensor> arguments) {
  // Get the kernel entrypoint function.
  const Function* compute = bef_file_->GetFunction(function_name);
  CHECK(compute) << "Entrypoint function not found";

  mutex_lock lock(mu_);
  auto it =
      cluster_compile_stats_.emplace(function.name(), ClusterCompileStats{})
          .first;
  RegisterExecutionForCluster(function, &it->second);
}

Status DeviceCompilationProfiler::RegisterCompilation(
    const NameAttrList& function, int64_t compile_time_us,
    bool used_persistent_cache) {
  metrics::UpdateXlaCompilationTime(compile_time_us);

// license that can be found in the LICENSE file.

package abi

// A FuncFlag records bits about a function, passed to the runtime.
type FuncFlag uint8

const (
	// FuncFlagTopFrame indicates a function that appears at the top of its stack.
	// The traceback routine stop at such a function and consider that a
	// successful, complete traversal of the stack.
	// Examples of TopFrame functions include goexit, which appears

)

// APILifecycleIntroduced is an autogenerated function, returning the release in which the API struct was introduced as int versions of major and minor for comparison.
// It is controlled by "k8s:prerelease-lifecycle-gen:introduced" tags in types.go.
func (in *FlowSchema) APILifecycleIntroduced() (major, minor int) {
	return 1, 26
}

```Python hl_lines="14"
{!../../../docs_src/background_tasks/tutorial001.py!}
```

`.add_task()` receives as arguments:

* A task function to be run in the background (`write_notification`).
* Any sequence of arguments that should be passed to the task function in order (`email`).

    @Test
    fun `defers evaluation of Function objects`() {
        assertDeferredEvaluationOf(function()) {
            invoke()
        }
    }

    @Test
    fun `defers evaluation of dynamic Function fields`() {
        assertDeferredEvaluationOf(BeanOf(function())) {
            value()
        }
    }

    @Test
    fun `defers evaluation of static Function fields`() {

// named "a" in that directory, the walk function will be called with
// argument "dir/a".
//
// The d argument is the [DirEntry] for the named path.
//
// The error result returned by the function controls how [WalkDir]
// continues. If the function returns the special value [SkipDir], WalkDir
// skips the current directory (path if d.IsDir() is true, otherwise
// path's parent directory). If the function returns the special value

    @Test
    fun `adding function may have a configuring lambda if it returns the added value`() {
        val schema = schemaFromTypes(ReceiverOne::class, listOf(ReceiverOne::class))
        val function = schema.dataClassesByFqName.values.single().memberFunctions.single()
        assertIs<FunctionSemantics.AddAndConfigure>(function.semantics)
    }

    @Test

    /**
     * Caches resolved variants created by the given function if the identifier is eligible for caching.
     *
     * @param key key for the cache
     * @param mappingFunction function to create a {@link ResolvedVariant}
     * @return the resolved variant created by the function or a cached instance, if available
     */
    ResolvedVariant computeIfAbsent(Identifier key, Function<? super Identifier, ? extends ResolvedVariant> mappingFunction);