*/
package org.apache.maven.execution;

import java.util.Objects;

import org.apache.maven.project.MavenProject;

/**
 * Summarizes the result of a project build in the reactor.
 *
 */
public abstract class BuildSummary {

    /**
     * The project being summarized.
     */
    private final MavenProject project;

    /**
     * The build time of the project in milliseconds.
     */

  // CHECK-NOT: tf.Assert
  "tf.Assert"(%t, %arg0) {summarize = 3} : (tensor<i1>, tensor<1x1x6x2xf32>) -> ()
  func.return
}

// CHECK-LABEL: func @tfAssertFalse
func.func @tfAssertFalse(%arg0: tensor<1x1x6x2xf32>) {
  %f = arith.constant dense<false> : tensor<i1>
  // CHECK: tf.Assert
  "tf.Assert"(%f, %arg0) {summarize = 3} : (tensor<i1>, tensor<1x1x6x2xf32>) -> ()
  func.return
}

		// https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
		// and extended for more than just bytes (like nibbles
		// and uint16s) by using an appropriate constant.
		//
		// To summarize the technique, quoting from that page:
		// "[It] works by first zeroing the high bits of the [8]
		// bytes in the word. Subsequently, it adds a number that
		// will result in an overflow to the high bit of a byte if

	//
	// However, the cons/mark ratio is a ratio of rates per CPU-second, but
	// here we care about the relative rates for some division of CPU
	// resources among the mutator and the GC.
	//
	// To summarize, we have B / cpu-ns, and we want B / ns. We get that
	// by multiplying by our desired division of CPU resources. We choose
	// to express CPU resources as GOMAPROCS*fraction. Note that because

		}

		var constraint *modload.ConstraintError
		if !errors.As(err, &constraint) {
			base.Fatal(err)
		}

		if cfg.BuildV {
			// Log complete paths for the conflicts before we summarize them.
			for _, c := range constraint.Conflicts {
				fmt.Fprintf(os.Stderr, "go: %v\n", c.String())
			}
		}

		// modload.EditBuildList reports constraint errors at

package org.apache.maven.execution;

import org.apache.maven.project.MavenProject;

/**
 * Summarizes the result of a successful project build in the reactor.
 *
 */
public class BuildSuccess extends BuildSummary {

    /**
     * Creates a new build summary for the specified project.
     *
     * @param project The project being summarized, must not be {@code null}.
     * @param time The build time of the project in milliseconds.

/**
 * Summarizes the result of a failed project build in the reactor.
 *
 */
public class BuildFailure extends BuildSummary {

    /**
     * The cause of the build failure.
     */
    private final Throwable cause;

    /**
     * Creates a new build summary for the specified project.
     *
     * @param project The project being summarized, must not be {@code null}.

  let arguments = (ins
    Variadic<TF_Tensor>:$inputs,

    DefaultValuedStrAttr<StrAttr, "%s">:$strtemplate,
    DefaultValuedStrAttr<StrAttr, "%s">:$placeholder,
    DefaultValuedOptionalAttr<I64Attr, "3">:$summarize
  );

  let results = (outs
    TF_StrTensor:$output
  );

  TF_DerivedOperandTypeListAttr T = TF_DerivedOperandTypeListAttr<0>;
}

  // expected-remark@above {{ID: 3}}
  %cond = builtin.unrealized_conversion_cast to tensor<i1>
  // expected-remark@above {{ID: 0}}
  "tf.Assert"(%cond, %arg1) {device = "/job:localhost/replica:0/task:0/device:CPU:0", summarize = 3 : i64} : (tensor<i1>, tensor<1xf32>) -> ()
  // expected-remark@above {{ID: 1}}
  func.return %cond : tensor<i1>
  // expected-remark@above {{ID: 2}}
  // expected-remark@above {{Sinks: {1}}}
}

    private
    val problemsService: InternalProblems,

    private
    val failureFactory: FailureFactory

) : AbstractProblemsListener(), ProblemReporter, AutoCloseable {

    private
    val summarizer = ConfigurationCacheProblemsSummary()

    private
    val buildNameHandler = BuildNameHandler()

    private
    val postBuildHandler = PostBuildProblemsHandler()

    private