import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.annotation.Nonnull;
import javax.annotation.meta.TypeQualifierDefault;

/**
 * Marks all "top-level" types as non-null in a way that is recognized by Kotlin. Note that this
 * unfortunately includes type-variable usages, so we also provide {@link ParametricNullness} to
 * "undo" it as best we can.
 */

import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import javax.annotation.Nonnull;
import javax.annotation.meta.TypeQualifierDefault;

/**
 * Marks all "top-level" types as non-null in a way that is recognized by Kotlin. Note that this
 * unfortunately includes type-variable usages, so we also provide {@link ParametricNullness} to
 * "undo" it as best we can.
 */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.tasks;

import java.lang.annotation.*;

/**
 * <p>Marks a property as specifying an output file for a task.</p>
 *
 * <p>This annotation should be attached to the getter method in Java or the property in Groovy.
 * Annotations on setters or just the field in Java are ignored.</p>
 *

namespace mlir {
namespace quant {
namespace {

// Name of the boolean attribute indicating whether the function can be
// inlined or not.
constexpr StringRef kTfNoinlineAttr = "tf._noinline";

// This pass marks functions with the attribute `tf._noinline = true` so that
// they aren't inlined by the `InlinerPass`. The names of the functions to be
// marked noinline should be specified by the `noinline-functions` option.

     */
    InputReferences inputReferences();

    /**
     * Returns the source location for this closure.
     */
    SourceLocation sourceLocation();

    /**
     * Marks this closure as a rule action, with the given inputs
     *
     * @param nestedRuleFactory Factory to use to create nested rules.
     */

	}

	if len(nonStmtLines)*100 > m*len(lines) {
		t.Errorf("Saw too many (%s, > %d%%) lines without statement marks, total=%d, nostmt=%d ('-run TestStmtLines -v' lists failing lines)\n", runtime.GOARCH, m, len(lines), len(nonStmtLines))
	}
	t.Logf("Saw %d out of %d lines without statement marks", len(nonStmtLines), len(lines))
	if testing.Verbose() {
		sort.Slice(nonStmtLines, func(i, j int) bool {

 * limitations under the License.
 */

package org.gradle.tooling.events.lifecycle;

import org.gradle.api.Incubating;
import org.gradle.tooling.events.StartEvent;

/**
 * An event that marks the start of a build phase.
 *
 * @since 7.6
 */
@Incubating
public interface BuildPhaseStartEvent extends BuildPhaseProgressEvent, StartEvent {

 */
package org.gradle.internal.resolve.result;

import javax.annotation.Nullable;

public interface ErroringResolveResult<E extends Throwable> extends ResolveResult {
    /**
     * Marks the resolution as failed with the given failure.
     */
    void failed(E error);

    /**
     * {@inheritDoc}
     */
    @Nullable
    @Override
    E getFailure();

// setting SetNonblock and CloseOnExec.

//go:build aix || darwin || (js && wasm) || wasip1

package poll

import (
	"syscall"
)

// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(s int) (int, syscall.Sockaddr, string, error) {
	// See ../syscall/exec_unix.go for description of ForkLock.

import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks a test class as needing to run twice, with and without fluid dependencies enabled.
 * <p>
 * When fluid dependencies are enabled, any configuration that is a task input is resolved when constructing the task graph.
 */