// TODO(minux): correctly handle __i686.get_pc_thunk.bx without
				// set dupok generally. See https://golang.org/cl/5823055
				// comment #5 for details.
				if s != 0 && elfsym.other == 2 {
					if !l.IsExternal(s) {
						l.MakeSymbolUpdater(s)
					}
					l.SetAttrDuplicateOK(s, true)
					l.SetAttrVisibilityHidden(s, true)
				}
			}

		case elf.STB_LOCAL:

	}

	if kubeDeps == nil {
		kubeDeps, err = UnsecuredDependencies(s, featureGate)
		if err != nil {
			return err
		}
	}

	if kubeDeps.Cloud == nil {
		if !cloudprovider.IsExternal(s.CloudProvider) {
			cloudprovider.DeprecationWarningForProvider(s.CloudProvider)
			cloud, err := cloudprovider.InitCloudProvider(s.CloudProvider, s.CloudConfigFile)
			if err != nil {
				return err
			}

            cutPart(lastIsInternal)
            this.lastIsInternal = null
        }

        private
        fun cutPart(isInternal: Boolean) {
            val text = drainBuffer()
            parts += StackTracePart(isInternal, text)
        }

        private
        fun drainBuffer(): String = buffer.toString().also { buffer.setLength(0) }
    }
}


private

    @Nullable
    @Override
    public StackTraceRelevance classify(StackTraceElement frame) {
        return isInternal(frame.getClassName()) ? StackTraceRelevance.INTERNAL : null;
    }

    private static boolean isInternal(String className) {
        // JDK calls
        return className.startsWith("java.") ||
            className.startsWith("jdk.") ||

		recorder:                       kubeDeps.Recorder,
		cadvisor:                       kubeDeps.CAdvisorInterface,
		cloud:                          kubeDeps.Cloud,
		externalCloudProvider:          cloudprovider.IsExternal(cloudProvider),
		providerID:                     providerID,
		nodeRef:                        nodeRef,
		nodeLabels:                     nodeLabels,

                                        input: 'a'
                                        input: 'b'
                                      )proto"),
                                      &kernel_);
  EXPECT_TRUE(absl::IsInternal(status)) << status;
}

TEST_F(XlaKernelCreatorTest, FailsIfXlaCompileAttrIsSetToFalse) {
  FunctionDef fdef = XTimesY();
  (*fdef.mutable_attr())["_XlaMustCompile"] = BoolAttr(false);
  Init({fdef});

        super.writeClassAnnotations(annotationMembers.filter { it.name != kotlinMetadataAnnotationSignature }.toSet())
    }

    override fun writeMethod(method: MethodMember) {
        when {
            method.isInternal() -> return
            method.isInline() -> throw CompileAvoidanceException.publicInlineFunction(method)
            else -> super.writeMethod(method)
        }
    }

    private

    }

    protected abstract boolean changed(JApiCompatibility member)

    protected abstract Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass)

    protected boolean isInternal(CtClass c) {
        if (c.name.startsWith("java.")) {
            return false
        } else if (c.name.contains('.internal.')) {
            return true
        } else {

  }

  // Verify passed in errors are propagated.
  {
    Status err = tensorflow::errors::Internal("Passed in error");
    ASSERT_TRUE(tensorflow::errors::IsInternal(
        StatusScopedDiagnosticHandler(&context).Combine(err)));
  }

  // Verify diagnostic reported are append to passed in error.
  {
    auto function = [&]() {

                ModelRegistrations.Builder builder = managedRegistrationBuilder(childPath, property, nodeInitializerRegistry, publicType);
                addLink(modelNode, builder, property.isInternal());
            } else {
                // A nullable reference
                modelNode.addReference(property.getName(), propertyType, null, modelNode.getDescriptor());
            }
        } else {