if in.bytes == nil {
		for ; p < len(in.str) && !utf8.RuneStart(in.str[p]); p++ {
		}
	} else {
		for ; p < len(in.bytes) && !utf8.RuneStart(in.bytes[p]); p++ {
		}
	}
	return p
}

func (in *input) appendSlice(buf []byte, b, e int) []byte {
	if in.bytes != nil {
		return append(buf, in.bytes[b:e]...)
	}
	for i := b; i < e; i++ {
		buf = append(buf, in.str[i])
	}
	return buf
}

	if in.bytes == nil {
		for ; p < len(in.str) && !utf8.RuneStart(in.str[p]); p++ {
		}
	} else {
		for ; p < len(in.bytes) && !utf8.RuneStart(in.bytes[p]); p++ {
		}
	}
	return p
}

func (in *input) appendSlice(buf []byte, b, e int) []byte {
	if in.bytes != nil {
		return append(buf, in.bytes[b:e]...)
	}
	for i := b; i < e; i++ {
		buf = append(buf, in.str[i])
	}
	return buf
}

		return fmt.Errorf("deleteFromSlicePtr parent type is %T, must be *[]interface{}", parentSlice)
	}

	pvv := pv.Elem()
	if pvv.Kind() == reflect.Interface {
		pvv = pvv.Elem()
	}

	pv.Elem().Set(reflect.AppendSlice(pvv.Slice(0, index), pvv.Slice(index+1, pvv.Len())))

	return nil
}

// UpdateSlicePtr updates an entry at index in the parent, which must be a slice ptr, with the given value.

            prettyPrint {
                appendLine("${KtDeclaration::class.simpleName}: ${declaration::class.simpleName}")

                appendLine("Symbol:")
                appendLine(symbol.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))

                appendLine()

                appendLine("Substitutor:")
                appendLine(stringRepresentation(substitutor))

                appendLine()

                .mapValues { (_, importedNames) -> importedNames.sorted() }

            appendLine("USED DECLARATIONS:")
            for ((path, elements) in sortedUsedDeclarations) {
                appendLine()
                appendLine("Declaration: $path")
                appendLine("By names: $elements")
            }

            appendLine()

            val sortedUnresolvedNames = importsAnalysis.unresolvedNames.sorted()

                    debugPrinter.appendLine(debugRenderer.render(analysisSession, symbol))
                    debugPrinter.appendLine()

                    prettyPrinter.withIndents(indentCount = declaration.parentsOfType<KtDeclaration>(withSelf = false).count()) {
                        prettyPrinter.appendLine(symbol.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))

                appendLine("Expression: ${expression.text}")
                appendLine("${KaType::class.simpleName}: ${type.render(position = Variance.INVARIANT)}")
                appendLine()
                appendLine("${KaTypeScope::class.simpleName}:")
                appendLine(typeScope?.let { renderForTests(it) } ?: "NO_SCOPE")
                appendLine()

                appendLine("Declaration Scope:")

            buildString {
                appendLine("${KtAnnotationEntry::class.simpleName}: ${annotationEntry.text}")
                appendLine()
                appendLine("Resolved annotation symbol:")
                appendLine(annotationClassSymbol.render(KtDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))
                appendLine()
                appendLine("Applicable targets: $applicableTargetsInOrder")
            }

                        appendLine()
                        visitValue(value, indent + 1)
                    }
                    if (documentNode.content.isNotEmpty()) {
                        appendLine()
                        documentNode.content.forEach { visitDocumentNode(it, indent + 1) }
                    } else {
                        appendLine()
                    }
                }

            prettyPrint {
                appendLine("PSI type: ${declaration.typeReference?.text}")
                appendLine("${KaType::class.simpleName}: ${type.render(position = Variance.INVARIANT)}")
                appendLine("substitutor.substitute: ${substituted.render(position = Variance.INVARIANT)}")
                appendLine("substitutor.substituteOrNull: ${substitutedOrNull?.render(position = Variance.INVARIANT)}")