/**
     * @return the current context with the characters moving forward from the write position erased.
     */
    AnsiContext eraseForward();

    /**
     * @return the current context with the entire line erased.
     */
    AnsiContext eraseAll();

    /**
     * @return the current context moved to the specified position.
     */
    AnsiContext cursorAt(Cursor cursor);

    /**

 * limitations under the License.
 */

/* Adjust top left logo */

.library-name a {
    position: relative;
    margin-left: 65px;
}

.library-name a::before {
    content: '';
    background: url("../images/gradle-logo.svg") center no-repeat;
    background-size: contain;
    position: absolute;
    width: 65px;
    height: 65px;
    top: -27px;
    left: -72px;
}

    return "AddInput";
  }
}

std::vector<string> ArgView::SetterArgs() const { return {VariableName()}; }

bool ArgView::IsList() const { return arg_.arg_type().is_list(); }

int ArgView::Position() const { return arg_.position(); }

}  // namespace cpp
}  // namespace generator

      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