// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math

// Abs returns the absolute value of x.
//
// Special cases are:
//
//	Abs(±Inf) = +Inf
//	Abs(NaN) = NaN
func Abs(x float64) float64 {
	return Float64frombits(Float64bits(x) &^ (1 << 63))

// Code generated by stringer -i a.out.go -o anames.go -p mips; DO NOT EDIT.

package mips

import "cmd/internal/obj"

var Anames = []string{
	obj.A_ARCHSPECIFIC: "ABSD",
	"ABSF",
	"ABSW",
	"ADD",
	"ADDD",
	"ADDF",
	"ADDU",
	"ADDW",
	"AND",
	"BEQ",
	"BFPF",
	"BFPT",
	"BGEZ",
	"BGEZAL",
	"BGTZ",
	"BLEZ",
	"BLTZ",
	"BLTZAL",
	"BNE",
	"BREAK",
	"CLO",
	"CLZ",
	"CMOVF",
	"CMOVN",

func (MyMer) String() string {
	return "aa"
}

// Parameterized interface
type Abs[T any] interface {
	Abs() T
}

func G[T Abs[U], U any](t T) {
	T.Abs(t)
	t.Abs()
}

type MyInt int
func (m MyInt) Abs() MyInt {
	if m < 0 {
		return -m
	}
	return m
}

type Abs2 interface {
	Abs() MyInt
}


func main() {
	mm := MyMer(3)
	ms := struct{ Mer }{Mer: mm }

}

// Check that it's using integer registers
func abs(x, y float64) {
	// amd64:"BTRQ\t[$]63"
	// arm64:"FABSD\t"
	// s390x:"LPDFR\t",-"MOVD\t"     (no integer load/store)
	// ppc64x:"FABS\t"
	// riscv64:"FABSD\t"
	// wasm:"F64Abs"
	// arm/6:"ABSD\t"
	// mips64/hardfloat:"ABSD\t"
	// mips/hardfloat:"ABSD\t"
	sink64[0] = math.Abs(x)

	// amd64:"BTRQ\t[$]63","PXOR"    (TODO: this should be BTSQ)

  }
}

// Runs model as is if output is a scalar,
// else sums the output tensor before returning.
Status RunAndMaybeSum(AbstractContext* ctx, Model forward,
                      absl::Span<AbstractTensorHandle* const> inputs,
                      absl::Span<AbstractTensorHandle*> outputs,
                      bool use_function) {
  AbstractTensorHandle* model_outputs[1];

  // Run the model.
  TF_RETURN_IF_ERROR(

// Code generated by stringer -i a.out.go -o anames.go -p loong64; DO NOT EDIT.

package loong64

import "cmd/internal/obj"

var Anames = []string{
	obj.A_ARCHSPECIFIC: "ABSD",
	"ABSF",
	"ADD",
	"ADDD",
	"ADDF",
	"ADDU",
	"ADDW",
	"AND",
	"BEQ",
	"BGEZ",
	"BLEZ",
	"BGTZ",
	"BLTZ",
	"BFPF",
	"BFPT",
	"BNE",
	"BREAK",
	"CLO",
	"CLZ",
	"CMPEQD",
	"CMPEQF",
	"CMPGED",
	"CMPGEF",

		z := q - p
		if z > 0.5 {
			p = p + 1
			z = q - p
		}
		z = q * Sin(Pi*z)
		if z == 0 {
			return Inf(signgam)
		}
		sq1, sq2 := stirling(q)
		absz := Abs(z)
		d := absz * sq1 * sq2
		if IsInf(d, 0) {
			z = Pi / absz / sq1 / sq2
		} else {
			z = Pi / d
		}
		return float64(signgam) * z
	}

	// Reduce argument
	z := 1.0
	for x >= 3 {
		x = x - 1
		z = z * x

    return absl::InternalError(
        absl::StrFormat("Failed to create tmp dir: '%s'", tmp_dir));
  }

  return tmp_dir;
}

absl::StatusOr<std::string> CreateTmpDir() {
  // The overloaded function uses the default env.
  return CreateTmpDir(tsl::Env::Default());
}

absl::Status WriteStringToFile(const absl::string_view file_path,
                               const absl::string_view data) {
  auto* env = tsl::Env::Default();

const char kTensorPrefix[] = "tftensor$";

}  // namespace

string MangleAttributeName(absl::string_view str) {
  return absl::StrCat(kAttributePrefix, str);
}

bool IsMangledAttributeName(absl::string_view str) {
  return absl::StartsWith(str, kAttributePrefix);
}

absl::string_view DemangleAttributeName(absl::string_view str) {
  DCHECK(IsMangledAttributeName(str));
  return str.substr(std::strlen(kAttributePrefix));

#include <cstdint>
#include <fstream>
#include <string>
#include <vector>

#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "absl/functional/any_invocable.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "tsl/platform/env.h"
#include "tsl/platform/file_system.h"
#include "tsl/platform/status_matchers.h"
#include "tsl/platform/types.h"