type testState struct {
	width   int
	widthOK bool
	prec    int
	precOK  bool
	flag    map[int]bool
}

var _ fmt.State = testState{}

func (s testState) Write(b []byte) (n int, err error) {
	panic("unimplemented")
}

func (s testState) Width() (wid int, ok bool) {
	return s.width, s.widthOK
}

func (s testState) Precision() (prec int, ok bool) {
	return s.prec, s.precOK
}

	return []byte("\"proto-result\""), nil
}

// DeepCopyObject implements runtime.Object interface.
func (*noncacheableTestObject) DeepCopyObject() runtime.Object {
	panic("DeepCopy unimplemented for noncacheableTestObject")
}

// GetObjectKind implements runtime.Object interface.
func (o *noncacheableTestObject) GetObjectKind() schema.ObjectKind {
	return o
}

  return tensorflow::errors::Unimplemented(
      "SetAttrFunction has not been implemented yet.");
}
Status SetAttrFunctionName(AbstractOperation* op_, const char* attr_name,
                           const char* value, size_t length,
                           ForwardOperation* forward_op_) {
  return tensorflow::errors::Unimplemented(
      "SetAttrFunctionName has not been implemented "

}

void PjRtDeviceCompilerClient::WaitForProgramsToFinish() {
  // TODO(b/255826209): Modify this if PjRtClient exposes a function to wait for
  // programs to finish.
  LOG(INFO) << "Unimplemented: PJRT uses futures and waiting for programs to "
               "finish isn't necessary.";
}

    *result = "(string)";
    return absl::OkStatus();
  }

  Status Sync() override { return absl::OkStatus(); }

  Status Tell(int64_t* position) override {
    return errors::Unimplemented("Stream not seekable");
  }

 private:
  string& str_;
};

TEST(Dump, TextualIrToFileSuccess) {
  Graph graph(OpRegistry::Global());
  Node* node;

	RET

TEXT runtime·access(SB),$0-12
	BREAK // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+8(FP)	// for vet
	RET

TEXT runtime·connect(SB),$0-16
	BREAK // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+12(FP)	// for vet
	RET

TEXT runtime·socket(SB),$0-16
	BREAK // unimplemented, only needed for android; declared in stubs_linux.go

                    AbstractTensorHandle* mat,
                    absl::Span<AbstractTensorHandle*> outputs) {
  if (!isa<ImmediateExecutionContext>(ctx)) {
    // TODO(b/168850692): Fix this.
    return errors::Unimplemented(
        "BroadcastMul is not supported in tracing mode yet.");
  }
  auto imm_ctx = dyn_cast<ImmediateExecutionContext>(ctx);
  AbstractTensorPtr minus_1(imm_ctx->CreateInt32Scalar(-1));

            break;
        case Smb2Constants.SMB2_DIALECT_0300:
        case Smb2Constants.SMB2_DIALECT_0302:
            signingKey = Smb3KeyDerivation.deriveSigningKey(dialect, sessionKey, new byte[0] /* unimplemented */);
            m = Mac.getInstance("AESCMAC", Crypto.getProvider());
            break;
        case Smb2Constants.SMB2_DIALECT_0311:
            if ( preauthIntegrityHash == null ) {

TEXT runtime·access(SB),$0-20
	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+16(FP) // for vet
	RET

TEXT runtime·connect(SB),$0-28
	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
	MOVW	R0, ret+24(FP) // for vet
	RET

TEXT runtime·socket(SB),$0-20
	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go

		}
	}
}

func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool {
	ld.Exitf("adddynrel currently unimplemented for MIPS")
	return false