* Processes the descendants of the element using the preorder implementation of tree traversal.
     */
    private inline fun <reified T : PsiElement> PsiElement.forEachDescendantOfType(
        noinline predicate: (T) -> Boolean = { true },
        noinline action: (T) -> Unit,
    ) = this.accept(object : PsiRecursiveElementVisitor() {
        override fun visitElement(element: PsiElement) {
            if (element is T && predicate(element)) {

// gcc -g -O2 -freorder-blocks-and-partition

const char *arr[10000];
const char *hot = "hot";
const char *cold = "cold";

__attribute__((noinline))
void fn(int path) {
	int i;

	if (path) {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = hot;
		}
	} else {
		for (i = 0; i < sizeof arr / sizeof arr[0]; i++) {
			arr[i] = cold;
		}
	}
}

int main(int argc, char *argv[]) {
	fn(argc);
	return 0;

// clang -gdwarf-5 -O2 -nostdlib

__attribute__((noinline, cold))
static int sum(int i) {
  int j, s;

  s = 0;
  for (j = 0; j < i; j++) {
    s += j * i;
  }
  return s;
}

int main(int argc, char** argv) {
  if (argc == 0) {
    return 0;
  }
  return sum(argc);

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type Value[T any] struct {
	val T
}

// The noinline directive should survive across import, and prevent instantiations
// of these functions from being inlined.

//go:noinline
func Get[T any](v *Value[T]) T {
	return v.val
}

//go:noinline

    final override val contextReceivers: List<KaContextReceiver> get() = withValidityAssertion { emptyList() }

    /**
     * Returns true if the function parameter is marked with `noinline` modifier
     */
    public abstract val isNoinline: Boolean

    /**
     * Returns true if the function parameter is marked with `crossinline` modifier
     */
    public abstract val isCrossinline: Boolean

import org.gradle.vcs.VersionControlSpec


/**
 * Specifies the VCS location for the requested component.
 *
 * @see VcsMapping.from
 */
inline fun <reified T : VersionControlSpec> VcsMapping.from(noinline configureAction: T.() -> Unit) =

 *
 * @see [PolymorphicDomainObjectContainer.register]
 */
inline fun <reified T : Any> PolymorphicDomainObjectContainer<in T>.register(name: String, noinline configuration: T.() -> Unit): NamedDomainObjectProvider<T> =
    register(name, T::class.java, configuration)


/**
 * Creates a domain object with the specified name and type, adds it to the container,

		cfg.Granularity = "addresses"
		cfg.NoInlines = false // Need inline info to support call expansion
	case "peek":
		trim = false
	case "list":
		trim = false
		cfg.Granularity = "lines"
		// Do not force 'noinlines' to be false so that specifying
		// "-list foo -noinlines" is supported and works as expected.
	case "text", "top", "topproto":
		if cfg.NodeCount == -1 {
			cfg.NodeCount = 0
		}
	default:

) = unsupported<T>(documentationSection) {
    text(description)
}


inline fun <reified T : Any> unsupported(
    documentationSection: DocumentationSection = DocumentationSection.RequirementsDisallowedTypes,
    noinline unsupportedMessage: StructuredMessageBuilder
): Codec<T> = codec(
    encode = {
        logUnsupported("serialize", documentationSection, unsupportedThings = unsupportedMessage)
    },
    decode = {

Anis Elleuch <******@****.***> 1653398798 +0100