status, ::tensorflow::Env::Default()->DeleteFile(filename));
}

bool TF_StringStreamNext(TF_StringStream* list, const char** result) {
  if (list->position >= list->list->size()) {
    *result = nullptr;
    return false;
  }

  *result = list->list->at(list->position++).c_str();
  return true;
}

void TF_StringStreamDone(TF_StringStream* list) {
  delete list->list;
  delete list;
}

     * @param position
     *            読み込みを開始する位置
     * @return 読み込んだバイト数
     */
    public static int read(final FileChannel channel, final ByteBuffer buffer, final long position) {
        assertArgumentNotNull("channel", channel);
        assertArgumentNotNull("buffer", buffer);

        try {
            return channel.read(buffer, position);
        } catch (final IOException e) {

                    val receiverSmartCasts = expression.getImplicitReceiverSmartCast()
                    for (receiverSmartCast in receiverSmartCasts) {
                        appendLine("receiver: ${receiverSmartCast.kind}")
                        appendLine("    smartCastType: ${receiverSmartCast.type.render(position = Variance.INVARIANT)}")
                    }

// ERROR "0:0"
x /* ERROR "3:1" */                // ignore automatically inserted semicolon here
/* ERROR "3:1" */                  // position of x on previous line
   x /* ERROR "5:4" */ ;           // do not ignore this semicolon
/* ERROR "5:24" */                 // position of ; on previous line
	package /* ERROR "7:2" */  // indented with tab
        import  /* ERROR "8:9" */  // indented with blanks
`

        }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val position = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
        val reference = mainFile.findReferenceAt(position)
        assertNotNull(reference)
        val expectedAlias = mainModule.testModule.directives.singleValue(Directives.TYPE_ALIAS)

) : KaSymbolDeclarationRendererProvider() {

    override fun renderType(type: KaType, renderer: KaTypeRenderer, position: Variance): String {
        return with(analysisSession) {
            val approximatedType = KaRendererTypeApproximator.TO_DENOTABLE.approximateType(analysisSession, type, position)
            prettyPrint { renderer.renderType(analysisSession, approximatedType, this) }
        }
    }

  public final int length() {
    return longs.length();
  }

  /**
   * Gets the current value at position {@code i}.
   *
   * @param i the index
   * @return the current value
   */
  public final double get(int i) {
    return longBitsToDouble(longs.get(i));
  }

  /**
   * Atomically sets the element at position {@code i} to the given value.
   *
   * @param i the index
   * @param newValue the new value

	imports              []rawImport
	embeds               []embed
	directives           []build.Directive
}

type rawImport struct {
	path     string
	position token.Position
}

type embed struct {
	pattern  string
	position token.Position
}

// importRaw fills the rawPackage from the package files in srcDir.
// dir is the package's path relative to the modroot.

										<div class="col-sm-6">
											<la:message key="labels.storage_tag_value" />
										</div>
									</div>
									<c:forEach var="position" begin="1" end="${savedTags.size()/2}">
									<c:set var="nameKey">name${position}</c:set>
									<c:set var="valueKey">value${position}</c:set>
									<div class="form-group row">
										<div class="col-sm-6">

    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun isVisible(
        candidateSymbol: KaSymbolWithVisibility,
        useSiteFile: KaFileSymbol,
        position: PsiElement,
        receiverExpression: KtExpression?
    ): Boolean {
        if (candidateSymbol.visibility == Visibilities.Public) {
            return true
        }