diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
index 4863bd7..07da6f1 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
@@ -241,6 +241,8 @@
             configuration.get(JVMConfigurationKeys.STRING_CONCAT) ?: JvmStringConcat.INDY_WITH_CONSTANTS
         else JvmStringConcat.INLINE
 
+    val mfvcVArrayFlatteningScheme = JvmMfvcVArrayFlatteningScheme.PER_SIZE // TODO init with respect to configuration
+
     val samConversionsScheme = run {
         val fromConfig = configuration.get(JVMConfigurationKeys.SAM_CONVERSIONS)
         if (fromConfig != null && target >= fromConfig.minJvmTarget)
diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmMfvcVArrayFlatteningScheme.kt b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmMfvcVArrayFlatteningScheme.kt
new file mode 100644
index 0000000..24d9909
--- /dev/null
+++ b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmMfvcVArrayFlatteningScheme.kt
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.config
+
+/**
+ * VArray<Mfvc> flattening scheme
+ *
+ * See [explanation](https://github.com/grechkovlad/vArrayBenchmarksReport) what do these schemes mean
+ */
+enum class JvmMfvcVArrayFlatteningScheme {
+    PER_TYPE, PER_SIZE, THREE_ARRAYS, TWO_ARRAYS
+}
\ No newline at end of file
diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt
index 3e9f952..12e11f1 100644
--- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt
+++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/IrBuiltInsOverFir.kt
@@ -415,6 +415,14 @@
         }
     }
 
+    override val vArrayIteratorFunction: IrSimpleFunctionSymbol? by lazy {
+        findFunctions(kotlinPackage, Name.identifier("iterator")).firstOrNull {
+            it.owner.extensionReceiverParameter?.type?.classOrNull == vArrayClass
+                    && it.owner.valueParameters.size == 0
+        }
+    }
+
+
     override lateinit var checkNotNullSymbol: IrSimpleFunctionSymbol private set
     override val arrayOfNulls: IrSimpleFunctionSymbol by lazy {
         findFunctions(kotlinPackage, Name.identifier("arrayOfNulls")).first {
diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java
index 65ceff7..2d7182b 100644
--- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java
+++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java
@@ -52198,6 +52198,124 @@
         public void testVarargParameterOfInlineType() throws Exception {
             runTest("compiler/testData/codegen/box/vArrays/varargParameterOfInlineType.kt");
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+
+            @Test
+            @TestMetadata("customIterator.kt")
+            public void testCustomIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("typesEncodings.kt")
+            public void testTypesEncodings() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt");
+            }
+
+            @Test
+            @TestMetadata("vArray2D.kt")
+            public void testVArray2D() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsFunctionParameter.kt")
+            public void testVArrayAsFunctionParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaParameter.kt")
+            public void testVArrayAsLambdaParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaReturnType.kt")
+            public void testVArrayAsLambdaReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsMfvcProperty.kt")
+            public void testVArrayAsMfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsProperty.kt")
+            public void testVArrayAsProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsPropertyNoBackingField.kt")
+            public void testVArrayAsPropertyNoBackingField() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsReturnType.kt")
+            public void testVArrayAsReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsSfvcProperty.kt")
+            public void testVArrayAsSfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayChainAssignment.kt")
+            public void testVArrayChainAssignment() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayExpression.kt")
+            public void testVArrayExpression() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInIfElseBlock.kt")
+            public void testVArrayInIfElseBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInTryBlock.kt")
+            public void testVArrayInTryBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInWhenExpr.kt")
+            public void testVArrayInWhenExpr() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayIterator.kt")
+            public void testVArrayIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("vArraySize.kt")
+            public void testVArraySize() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt");
+            }
+        }
     }
 
     @Nested
diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java
index db04d46..89e56b1 100644
--- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java
+++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java
@@ -52198,6 +52198,124 @@
         public void testVarargParameterOfInlineType() throws Exception {
             runTest("compiler/testData/codegen/box/vArrays/varargParameterOfInlineType.kt");
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+
+            @Test
+            @TestMetadata("customIterator.kt")
+            public void testCustomIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("typesEncodings.kt")
+            public void testTypesEncodings() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt");
+            }
+
+            @Test
+            @TestMetadata("vArray2D.kt")
+            public void testVArray2D() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsFunctionParameter.kt")
+            public void testVArrayAsFunctionParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaParameter.kt")
+            public void testVArrayAsLambdaParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaReturnType.kt")
+            public void testVArrayAsLambdaReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsMfvcProperty.kt")
+            public void testVArrayAsMfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsProperty.kt")
+            public void testVArrayAsProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsPropertyNoBackingField.kt")
+            public void testVArrayAsPropertyNoBackingField() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsReturnType.kt")
+            public void testVArrayAsReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsSfvcProperty.kt")
+            public void testVArrayAsSfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayChainAssignment.kt")
+            public void testVArrayChainAssignment() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayExpression.kt")
+            public void testVArrayExpression() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInIfElseBlock.kt")
+            public void testVArrayInIfElseBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInTryBlock.kt")
+            public void testVArrayInTryBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInWhenExpr.kt")
+            public void testVArrayInWhenExpr() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayIterator.kt")
+            public void testVArrayIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("vArraySize.kt")
+            public void testVArraySize() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt");
+            }
+        }
     }
 
     @Nested
diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt
index 3e969c7..3a8548f 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt
@@ -9,16 +9,22 @@
 import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.backend.jvm.codegen.PromisedValue
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
+import org.jetbrains.kotlin.ir.types.classFqName
 import org.jetbrains.kotlin.ir.util.isPrimitiveArray
 
 object IrDataClassArrayMemberHashCode : IntrinsicMethod() {
     override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
         with(codegen) {
             val arrayType = expression.getValueArgument(0)!!.type
-            val asmArrayType = codegen.typeMapper.mapType(arrayType)
-            gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data)
-            val hashCodeArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;"
-            mv.invokestatic("java/util/Arrays", "hashCode", "($hashCodeArgumentDescriptor)I", false)
+            // TODO: temporary solution until implementation of VArrays.hashCode()
+            if (arrayType.classFqName!!.shortName().asString().startsWith("VArrayWrapper")) {
+                mv.aconst(0)
+            } else {
+                val asmArrayType = codegen.typeMapper.mapType(arrayType)
+                gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data)
+                val hashCodeArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;"
+                mv.invokestatic("java/util/Arrays", "hashCode", "($hashCodeArgumentDescriptor)I", false)
+            }
             return expression.onStack
         }
 }
diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt
index 162d58d..f29311f 100644
--- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt
+++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt
@@ -9,16 +9,22 @@
 import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen
 import org.jetbrains.kotlin.backend.jvm.codegen.PromisedValue
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
+import org.jetbrains.kotlin.ir.types.classFqName
 import org.jetbrains.kotlin.ir.util.isPrimitiveArray
 
 object IrDataClassArrayMemberToString : IntrinsicMethod() {
     override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? =
         with(codegen) {
             val arrayType = expression.getValueArgument(0)!!.type
-            val asmArrayType = codegen.typeMapper.mapType(arrayType)
-            gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data)
-            val toStringArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;"
-            mv.invokestatic("java/util/Arrays", "toString", "($toStringArgumentDescriptor)Ljava/lang/String;", false)
+            // TODO: temporary solution until implementation of VArrays.toString()
+            if (arrayType.classFqName!!.shortName().asString().startsWith("VArrayWrapper")) {
+                mv.aconst("STUB")
+            } else {
+                val asmArrayType = codegen.typeMapper.mapType(arrayType)
+                gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data)
+                val toStringArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;"
+                mv.invokestatic("java/util/Arrays", "toString", "($toStringArgumentDescriptor)Ljava/lang/String;", false)
+            }
             return expression.onStack
         }
 }
diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
index 21f1bb8..c16460b 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt
@@ -14,6 +14,7 @@
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.*
@@ -101,6 +102,8 @@
     }
 
     override fun handleSpecificNewClass(declaration: IrClass) {
+        transformInlineClassRepresentationIfNeeded(declaration)
+
         val irConstructor = declaration.primaryConstructor!!
         // The field getter is used by reflection and cannot be removed here unless it is internal.
         declaration.declarations.removeIf {
@@ -113,6 +116,16 @@
         addJvmInlineAnnotation(declaration)
     }
 
+    private fun transformInlineClassRepresentationIfNeeded(declaration: IrClass) {
+        require(declaration.inlineClassRepresentation != null)
+        val inlineClassRepresentation = declaration.inlineClassRepresentation!!
+        val transformedUnderlyingType =
+            applyVArrayWrappingTypeTransformation(inlineClassRepresentation.underlyingType, replacements.flatteningSymbolsHelper)
+        require(transformedUnderlyingType is IrSimpleType)
+        declaration.valueClassRepresentation =
+            InlineClassRepresentation(inlineClassRepresentation.underlyingPropertyName, transformedUnderlyingType)
+    }
+
     private fun addJvmInlineAnnotation(valueClass: IrClass) {
         if (valueClass.hasAnnotation(JVM_INLINE_ANNOTATION_FQ_NAME)) return
         val constructor = context.ir.symbols.jvmInlineAnnotation.constructors.first()
diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
index 164a1e1..f657cd5 100644
--- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
+++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt
@@ -8,6 +8,7 @@
 import org.jetbrains.kotlin.backend.common.ScopeWithIr
 import org.jetbrains.kotlin.backend.common.ir.inline
 import org.jetbrains.kotlin.backend.common.lower.irCatch
+import org.jetbrains.kotlin.backend.common.lower.irThrow
 import org.jetbrains.kotlin.backend.common.pop
 import org.jetbrains.kotlin.backend.common.push
 import org.jetbrains.kotlin.backend.jvm.*
@@ -19,9 +20,7 @@
 import org.jetbrains.kotlin.backend.jvm.lower.BlockOrBody.Block
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.declarations.*
@@ -30,16 +29,13 @@
 import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrEnumConstructorCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
-import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
+import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl
-import org.jetbrains.kotlin.ir.transformStatement
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.*
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.utils.addIfNotNull
 
 internal class JvmMultiFieldValueClassLowering(
@@ -196,6 +192,49 @@
             return getterExpression
         }
 
+        fun IrBlockBuilder.lowerMfvcVArrayGet(expression: IrCall): IrExpression {
+            val mfvcNode = replacements.getRootMfvcNode(expression.type.erasedUpperBound)
+            val mapper = replacements.getMfvcVArrayMapper(mfvcNode)
+            require(expression.dispatchReceiver != null)
+            val vArrayWrapperTempVariable = savableStandaloneVariableWithSetter(
+                expression = expression.dispatchReceiver!!,
+                origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+                saveVariable = ::variablesSaver
+            )
+            require(expression.valueArgumentsCount == 1)
+            val indexInVArrayExpr = expression.getValueArgument(0)!!
+            val indexInVArrayTempVariable = savableStandaloneVariableWithSetter(
+                expression = indexInVArrayExpr,
+                origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+                saveVariable = ::variablesSaver
+            )
+            val tempVariables = List(mfvcNode.leavesCount) { leafIndex ->
+                val mapping = mapper.map(indexInVArrayTempVariable, leafIndex, this, replacements.flatteningSymbolsHelper)
+                val leafValue = irCall(mapping.wrapperArrayGetFunction).apply {
+                    dispatchReceiver = irGetField(
+                        irGet(vArrayWrapperTempVariable),
+                        mapping.wrapperField.owner
+                    )
+                    putValueArgument(0, mapping.indexInWrapperArray)
+                }
+                val decodedValue = mapping.decodeFunction(leafValue, this)
+                // TODO: Investigate how to get rid of temporary variables. They are presumably blame for excess bytecode.
+                savableStandaloneVariableWithSetter(
+                    decodedValue,
+                    name = null,
+                    isMutable = false,
+                    origin = JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE,
+                    saveVariable = ::variablesSaver
+                )
+            }
+            val typeArguments = makeTypeArgumentsFromType(expression.type as IrSimpleType)
+            val nodeInstance = ValueDeclarationMfvcNodeInstance(mfvcNode, typeArguments, tempVariables)
+            val resultExpr = nodeInstance.makeGetterExpression(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
+            registerReplacement(resultExpr, nodeInstance)
+            +resultExpr
+            return resultExpr
+        }
+
         private fun makeTypeArgumentsFromField(expression: IrFieldAccessExpression) = buildMap {
             val field = expression.symbol.owner
             putAll(makeTypeArgumentsFromType(field.type as IrSimpleType))
@@ -303,9 +342,15 @@
             }
         }
 
+        transformVArrayTypes(declaration)
+
         return declaration
     }
 
+    private fun transformVArrayTypes(declaration: IrClass) {
+        declaration.transformChildrenVoid(MfvcVArrayTypeWrapperVisitor(replacements.flatteningSymbolsHelper))
+    }
+
     override fun visitClassNewDeclarationsWhenParallel(declaration: IrDeclaration) =
         postActionAfterTransformingClassDeclaration(declaration)
 
@@ -963,6 +1008,24 @@
                 }
             }
 
+            isCreationOfFlattenedVArray(expression, context) -> {
+                context.createJvmIrBuilder(currentScope.symbol, expression).irBlock {
+                    require(expression.typeArgumentsCount == 1)
+                    val rootNode = replacements.getRootMfvcNode(expression.getTypeArgument(0)!!.erasedUpperBound)
+                    val flatteningScheme = replacements.getMfvcVArrayMapper(rootNode)
+                    require(expression.valueArgumentsCount == 1)
+                    val vArraySizeExpr = expression.getValueArgument(0)!!
+                    val constructorCall =
+                        flatteningScheme.getVArrayWrapperCreationCall(
+                            vArraySizeExpr,
+                            this,
+                            replacements.flatteningSymbolsHelper,
+                            ::variablesSaver
+                        )
+                    +constructorCall
+                }.unwrapBlock()
+            }
+
             replacement != null -> context.createJvmIrBuilder(currentScope.symbol, expression).irBlock {
                 buildReplacement(function, expression, replacement)
             }.unwrapBlock()
@@ -1069,9 +1132,177 @@
                 }
             }.unwrapBlock()
         }
+        if (isGetOnFlattenedVArray(expression, replacements.flatteningSymbolsHelper)) {
+            expression.transformChildrenVoid()
+            return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock {
+                with(valueDeclarationsRemapper) {
+                    lowerMfvcVArrayGet(expression)
+                }
+            }.unwrapBlock()
+        }
+        if (isSetOnFlattenVArray(expression, replacements.flatteningSymbolsHelper)) {
+            expression.transformChildrenVoid()
+            val flattenSetBlock = context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock {
+                lowerMfvcVArraySet(expression)
+            }
+            return flattenSetBlock
+        }
+        if (isGetSizeOnFlattenedVArray(expression, replacements.flatteningSymbolsHelper)) {
+            expression.transformChildrenVoid()
+            return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression)
+                .irGetField(expression.dispatchReceiver!!, replacements.flatteningSymbolsHelper.wrapperSizeField.owner)
+        }
+        if (isFlattenedVArrayIteratorCreation(expression, context)) {
+            require(expression.extensionReceiver != null)
+            expression.transformChildrenVoid()
+            return with(context.createJvmIrBuilder(getCurrentScopeSymbol(), expression)) {
+                irCall(replacements.flatteningSymbolsHelper.vArrayWrapperIteratorStateHolderConstructor).apply {
+                    putValueArgument(0, expression.extensionReceiver)
+                    putValueArgument(1, irInt(0))
+                }
+            }
+        }
+        if (isFlattenedVArrayIteratorHasNext(expression)) {
+            expression.transformChildrenVoid()
+            return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock {
+                lowerMfvcVArrayIteratorHasNext(expression)
+            }
+        }
+        if (isFlattenedVArrayIteratorNext(expression)) {
+            val lowered = context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock {
+                lowerMfvcVArrayIteratorNext(expression)
+            }
+            lowered.transformChildrenVoid()
+            return lowered
+        }
         return super.visitCall(expression)
     }
 
+    private fun IrBlockBuilder.lowerMfvcVArrayIteratorNext(expression: IrCall) {
+        require(expression.dispatchReceiver != null)
+        val symbols = replacements.flatteningSymbolsHelper
+        // Generate IR for:
+        // try { it.array[it.index++] } catch (e: ArrayIndexOutOfBoundsException) { it.index--; throw NoSuchElementException(e.message) }
+        val iteratorTempVariable = savableStandaloneVariableWithSetter(
+            expression = expression.dispatchReceiver!!,
+            origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+            saveVariable = ::variablesSaver
+        )
+        val vArrayGet = irCall(symbols.vArrayGet!!, expression.type).apply {
+            dispatchReceiver = irGetField(irGet(iteratorTempVariable), symbols.vArrayWrapperIteratorStateHolderArrayField.owner)
+            putValueArgument(0, irBlock {
+                val indexTempVariable = savableStandaloneVariableWithSetter(
+                    expression = irGetField(irGet(iteratorTempVariable), symbols.vArrayWrapperIteratorStateHolderIndexField.owner),
+                    origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+                    saveVariable = ::variablesSaver
+                )
+                +irSetField(
+                    irGet(iteratorTempVariable),
+                    symbols.vArrayWrapperIteratorStateHolderIndexField.owner,
+                    irCall(context.irBuiltIns.intClass.getSimpleFunction("inc")!!).apply {
+                        dispatchReceiver = irGet(indexTempVariable)
+                    }
+                )
+                +irGet(indexTempVariable)
+            })
+        }
+        val catchParameter = savableStandaloneVariable(
+            type = this@JvmMultiFieldValueClassLowering.context.ir.symbols.arrayIndexOutOfBoundsException.defaultType,
+            isVar = false,
+            origin = IrDeclarationOrigin.CATCH_PARAMETER,
+            saveVariable = {}
+        )
+        +irTry(
+            type = expression.type,
+            tryResult = vArrayGet,
+            catches = listOf(irCatch(
+                catchParameter = catchParameter,
+                result = irBlock {
+                    +irSetField(
+                        irGet(iteratorTempVariable),
+                        symbols.vArrayWrapperIteratorStateHolderIndexField.owner,
+                        irCall(context.irBuiltIns.intClass.getSimpleFunction("dec")!!).apply {
+                            dispatchReceiver =
+                                irGetField(irGet(iteratorTempVariable), symbols.vArrayWrapperIteratorStateHolderIndexField.owner)
+                        })
+                    +irThrow(irCall(symbols.noSuchElementExceptionConstructor).apply {
+                        putValueArgument(0, irCall(symbols.throwableMessageGetter).apply {
+                            dispatchReceiver = irGet(catchParameter)
+                        })
+                    })
+                }
+            )),
+            finallyExpression = null
+        )
+    }
+
+    private fun IrBlockBuilder.lowerMfvcVArrayIteratorHasNext(expression: IrCall) {
+        require(expression.dispatchReceiver != null)
+        val iteratorTempVariable = savableStandaloneVariableWithSetter(
+            expression = expression.dispatchReceiver!!,
+            origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+            saveVariable = ::variablesSaver
+        )
+        // IR for: iteratorStateHolder.index < iteratorStateHolder.array.size
+        +irCall(context.irBuiltIns.lessFunByOperandType[context.irBuiltIns.intType.classifierOrFail]!!).apply {
+            putValueArgument(
+                0,
+                irGetField(
+                    irGet(iteratorTempVariable),
+                    replacements.flatteningSymbolsHelper.vArrayWrapperIteratorStateHolderIndexField.owner
+                )
+            )
+            putValueArgument(
+                1,
+                irGetField(
+                    irGetField(
+                        irGet(iteratorTempVariable),
+                        replacements.flatteningSymbolsHelper.vArrayWrapperIteratorStateHolderArrayField.owner
+                    ), replacements.flatteningSymbolsHelper.wrapperSizeField.owner
+                )
+            )
+        }
+    }
+
+    private fun IrBlockBuilder.lowerMfvcVArraySet(setCall: IrCall) {
+        require(setCall.valueArgumentsCount == 2)
+        val vArrayIndexExpr = setCall.getValueArgument(0)!!
+        val vArrayIndexTempVariable = savableStandaloneVariableWithSetter(
+            expression = vArrayIndexExpr,
+            origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+            saveVariable = ::variablesSaver
+        )
+        val tempVariableForSetValue = savableStandaloneVariableWithSetter(
+            setCall.getValueArgument(1)!!,
+            origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+            saveVariable = ::variablesSaver
+        )
+        require(setCall.dispatchReceiver != null)
+        val vArrayWrapperTempVariable = savableStandaloneVariableWithSetter(
+            expression = setCall.dispatchReceiver!!,
+            origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+            saveVariable = ::variablesSaver
+        )
+        val mfvcNode = replacements.getRootMfvcNode(setCall.getValueArgument(1)!!.type.erasedUpperBound)
+        val mapper = replacements.getMfvcVArrayMapper(mfvcNode)
+        mfvcNode.leaves.forEachIndexed { leafIndex, leaf ->
+            val mapping = mapper.map(vArrayIndexTempVariable, leafIndex, this, replacements.flatteningSymbolsHelper)
+            val leafValue = irCall(leaf.unboxMethod).apply {
+                dispatchReceiver = irGet(tempVariableForSetValue)
+            }
+            val encodedValue = mapping.encodeFunction(leafValue, this)
+            val leafSetCall = irCall(mapping.wrapperArraySetFunction).apply {
+                dispatchReceiver = irGetField(
+                    irGet(vArrayWrapperTempVariable),
+                    mapping.wrapperField.owner
+                )
+                putValueArgument(0, mapping.indexInWrapperArray)
+                putValueArgument(1, encodedValue)
+            }
+            +leafSetCall
+        }
+    }
+
     private fun IrBlockBuilder.buildReplacement(
         originalFunction: IrFunction,
         original: IrMemberAccessExpression<*>,
@@ -1671,3 +1902,70 @@
     clear()
     addAll(replacement)
 }
+
+private fun isFlattenedVArrayIterator(type: IrType): Boolean {
+    if (type !is IrSimpleType) return false
+    if (type.classFqName != StandardClassIds.vArrayIterator.asSingleFqName()) return false
+    require(type.arguments.size == 1)
+    val typeArg = type.arguments[0]
+    require(typeArg is IrSimpleType)
+    return typeArg.needsMfvcFlattening()
+}
+
+private fun isFlattenedVArrayIteratorNext(expression: IrCall): Boolean {
+    if (expression.dispatchReceiver == null) return false
+    return isFlattenedVArrayIterator(expression.dispatchReceiver!!.type) && expression.symbol.owner.name == Name.identifier("next")
+}
+
+private fun isFlattenedVArrayIteratorHasNext(expression: IrCall): Boolean {
+    if (expression.dispatchReceiver == null) return false
+    return isFlattenedVArrayIterator(expression.dispatchReceiver!!.type) && expression.symbol.owner.name == Name.identifier("hasNext")
+}
+
+private fun isFlattenedVArrayIteratorCreation(expression: IrCall, context: JvmBackendContext) =
+    expression.symbol == context.irBuiltIns.vArrayIteratorFunction && expression.extensionReceiver?.type?.isFlattenedVArray() == true
+
+private fun isCreationOfFlattenedVArray(expression: IrFunctionAccessExpression, context: JvmBackendContext) =
+    expression.symbol == context.irBuiltIns.vArrayOfNulls && expression.type.isFlattenedVArray()
+
+private fun isGetSizeOnFlattenedVArray(expression: IrCall, symbols: FlatteningSymbolsHelper) =
+    expression.symbol == symbols.vArraySizeGetter && expression.dispatchReceiver?.type?.isFlattenedVArray() == true
+
+private fun isGetOnFlattenedVArray(expression: IrCall, symbols: FlatteningSymbolsHelper) =
+    expression.symbol == symbols.vArrayGet && expression.type.needsMfvcFlattening()
+
+private fun isSetOnFlattenVArray(expression: IrCall, symbols: FlatteningSymbolsHelper) =
+    expression.symbol == symbols.vArraySet && expression.getValueArgument(1)?.type?.needsMfvcFlattening() == true
+
+private class MfvcVArrayTypeWrapperVisitor(private val symbols: FlatteningSymbolsHelper) :
+    IrElementTransformerVoid() {
+
+    override fun visitCall(expression: IrCall): IrExpression {
+        return visitExpression(expression)
+    }
+
+    override fun visitExpression(expression: IrExpression): IrExpression {
+        expression.type = applyVArrayWrappingTypeTransformation(expression.type, symbols)
+        return super.visitExpression(expression)
+    }
+
+    override fun visitValueParameter(declaration: IrValueParameter): IrStatement {
+        declaration.type = applyVArrayWrappingTypeTransformation(declaration.type, symbols)
+        return super.visitValueParameter(declaration)
+    }
+
+    override fun visitField(declaration: IrField): IrStatement {
+        declaration.type = applyVArrayWrappingTypeTransformation(declaration.type, symbols)
+        return super.visitField(declaration)
+    }
+
+    override fun visitVariable(declaration: IrVariable): IrStatement {
+        declaration.type = applyVArrayWrappingTypeTransformation(declaration.type, symbols)
+        return super.visitVariable(declaration)
+    }
+
+    override fun visitFunction(declaration: IrFunction): IrStatement {
+        declaration.returnType = applyVArrayWrappingTypeTransformation(declaration.returnType, symbols)
+        return super.visitFunction(declaration)
+    }
+}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
index 0606ee3..24286e6 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt
@@ -649,6 +649,54 @@
     val arrayOfAnyType = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyType)
     val arrayOfAnyNType = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyNType)
 
+    private fun IrClass.addPrimaryConstructorByFields() {
+        addConstructor { isPrimary = true }.apply {
+            fields.forEach { field -> addValueParameter(field.name, field.type) }
+        }
+    }
+
+    val vArrayWrapperPerSizeClass: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.VArrayWrapperPerSize")) { klass ->
+        klass.addField("ones", irBuiltIns.byteArray.defaultType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("twos", irBuiltIns.shortArray.defaultType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("fours", irBuiltIns.intArray.defaultType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("eights", irBuiltIns.longArray.defaultType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("refs", arrayOfAnyNType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("size", irBuiltIns.intType, DescriptorVisibilities.PUBLIC)
+
+        klass.addPrimaryConstructorByFields()
+    }
+
+    val vArrayWrapperTwoArrays: IrClassSymbol = createClass(FqName("kotlin.jvm.internal.VArrayWrapperTwoArrays")) { klass ->
+        klass.addField("longs", irBuiltIns.longArray.defaultType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("refs", arrayOfAnyNType.makeNullable(), DescriptorVisibilities.PUBLIC)
+        klass.addField("size", irBuiltIns.intType, DescriptorVisibilities.PUBLIC)
+
+        klass.addPrimaryConstructorByFields()
+    }
+
+    val vArrayPerSizeIteratorStateHolder: IrClassSymbol =
+        createClass(FqName("kotlin.jvm.internal.VArrayPerSizeIteratorStateHolder")) { klass ->
+            klass.addField("array", vArrayWrapperPerSizeClass.owner.defaultType, DescriptorVisibilities.PUBLIC)
+            klass.addField("index", irBuiltIns.intType, DescriptorVisibilities.PUBLIC)
+
+            klass.addPrimaryConstructorByFields()
+        }
+
+    val vArrayTwoArraysIteratorStateHolder: IrClassSymbol =
+        createClass(FqName("kotlin.jvm.internal.VArrayTwoArraysIteratorStateHolder")) { klass ->
+            klass.addField("array", vArrayWrapperTwoArrays.owner.defaultType, DescriptorVisibilities.PUBLIC)
+            klass.addField("index", irBuiltIns.intType, DescriptorVisibilities.PUBLIC)
+
+            klass.addPrimaryConstructorByFields()
+        }
+
+    val arrayIndexOutOfBoundsException: IrClassSymbol = createClass(FqName("java.lang.ArrayIndexOutOfBoundsException"))
+    val noSuchElementException: IrClassSymbol = createClass(FqName("java.util.NoSuchElementException")) { klass ->
+        klass.addConstructor().apply {
+            addValueParameter("message", string.defaultType)
+        }
+    }
+
     // Intrinsic to represent closure creation using INVOKEDYNAMIC with LambdaMetafactory.{metafactory, altMetafactory}
     // as a bootstrap method.
     //      fun <SAM_TYPE> `<jvm-indy-lambda-metafactory>`(
@@ -832,6 +880,60 @@
         }
     }
 
+    val charCodeGetter: IrFunctionSymbol =
+        irFactory.buildProperty {
+            name = Name.identifier("code")
+        }.apply {
+            parent = createClass(FqName("kotlin.CharCodeKt")).owner
+            addGetter().apply {
+                isInline = true
+                addExtensionReceiver(irBuiltIns.charType)
+                returnType = irBuiltIns.intType
+            }
+        }.getter!!.symbol
+
+    val floatToRawBits: IrFunctionSymbol =
+        irFactory.buildFun {
+            name = Name.identifier("toRawBits")
+        }.apply {
+            isInline = true
+            parent = createClass(FqName("kotlin.NumbersKt__NumbersJVMKt")).owner
+            addExtensionReceiver(irBuiltIns.floatType)
+            returnType = irBuiltIns.intType
+        }.symbol
+
+    val floatFromBits: IrSimpleFunctionSymbol =
+        irFactory.buildFun {
+            name = Name.identifier("fromBits")
+        }.apply {
+            isInline = true
+            parent = createClass(FqName("kotlin.NumbersKt__NumbersJVMKt")).owner
+            addExtensionReceiver(irBuiltIns.floatClass.owner.companionObject()!!.defaultType)
+            addValueParameter("bits", irBuiltIns.intType)
+            returnType = irBuiltIns.floatType
+        }.symbol
+
+    val doubleFromBits: IrSimpleFunctionSymbol =
+        irFactory.buildFun {
+            name = Name.identifier("fromBits")
+        }.apply {
+            isInline = true
+            parent = createClass(FqName("kotlin.NumbersKt__NumbersJVMKt")).owner
+            addExtensionReceiver(irBuiltIns.doubleClass.owner.companionObject()!!.defaultType)
+            addValueParameter("bits", irBuiltIns.longType)
+            returnType = irBuiltIns.doubleType
+        }.symbol
+
+    val doubleToRawBits: IrFunctionSymbol =
+        irFactory.buildFun {
+            name = Name.identifier("toRawBits")
+        }.apply {
+            isInline = true
+            parent = createClass(FqName("kotlin.NumbersKt__NumbersJVMKt")).owner
+            addExtensionReceiver(irBuiltIns.doubleType)
+            returnType = irBuiltIns.longType
+        }.symbol
+
     val kClassJava: IrPropertySymbol =
         irFactory.buildProperty {
             name = Name.identifier("java")
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt
index 48e194d..254134f 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt
@@ -7,6 +7,7 @@
 
 import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping
 import org.jetbrains.kotlin.backend.jvm.ir.*
+import org.jetbrains.kotlin.config.JvmMfvcVArrayFlatteningScheme
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor
@@ -15,9 +16,7 @@
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
-import org.jetbrains.kotlin.ir.types.IrSimpleType
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.defaultType
+import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver
@@ -307,6 +306,15 @@
         getRootNode(context, it)
     }
 
+    val getMfvcVArrayMapper: (RootMfvcNode) -> MfvcVArrayMapper = storageManager.createMemoizedFunction {
+        when (context.state.mfvcVArrayFlatteningScheme) {
+            JvmMfvcVArrayFlatteningScheme.PER_TYPE -> TODO("Scheme is not implemented yet")
+            JvmMfvcVArrayFlatteningScheme.PER_SIZE -> PerSizeMapper(it, flatteningSymbolsHelper)
+            JvmMfvcVArrayFlatteningScheme.THREE_ARRAYS -> TODO("Scheme is not implemented yet")
+            JvmMfvcVArrayFlatteningScheme.TWO_ARRAYS -> TwoArraysMapper(it, flatteningSymbolsHelper)
+        }
+    }
+
     fun getRootMfvcNodeOrNull(irClass: IrClass): RootMfvcNode? =
         if (irClass.defaultType.needsMfvcFlattening()) getRootMfvcNode(irClass) else null
 
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt
index 8304a1d..f4bda22 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt
@@ -26,6 +26,8 @@
 ) {
     private val propertyMap = ConcurrentHashMap<IrPropertySymbol, IrProperty>()
 
+    val flatteningSymbolsHelper = FlatteningSymbolsHelper(context)
+
     /**
      * Get a replacement for a function or a constructor.
      */
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt
index c5abecd..7e4f1cc 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt
@@ -24,6 +24,7 @@
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.name.StandardClassIds
 
 typealias TypeArguments = Map<IrTypeParameterSymbol, IrType>
 
@@ -458,3 +459,27 @@
         classifierOrNull.let { classifier ->
             classifier is IrTypeParameterSymbol && classifier.owner.superTypes.any { it.needsMfvcFlattening() }
         } // add not is annotated as @UseBox etc
+
+fun IrType.isFlattenedVArray() =
+    isVArray && (this as? IrSimpleType)?.arguments?.let { it.size == 1 && ((it[0] as? IrType)?.needsMfvcFlattening() == true) } == true
+
+fun applyVArrayWrappingTypeTransformation(irType: IrType, symbols: FlatteningSymbolsHelper): IrType = when {
+    // TODO Investigate if we need to transform arguments of non-reified type, i.e. X<VArray<MFVC>> -> X<VArrayWrapper>
+    irType.isFlattenedVArray() -> symbols.vArrayWrapperClass.defaultType
+    irType.isVArray -> {
+        val typeArg = (irType as IrSimpleType).arguments[0]
+        require(typeArg is IrType)
+        symbols.backendContext.irBuiltIns.vArrayClass!!.typeWith(applyVArrayWrappingTypeTransformation(typeArg, symbols))
+    }
+    irType.isBoxedArray -> irType // TODO Transform array type argument, i.e. Array<VArray<Mfvc>> -> Array<VArrayWrapper>
+    isFlattenedVArrayIterator(irType) -> symbols.vArrayWrapperIteratorStateHolderClass.defaultType
+    else -> irType
+}
+
+fun isFlattenedVArrayIterator(irType: IrType): Boolean {
+    if (irType !is IrSimpleType) return false
+    if (irType.classFqName != StandardClassIds.vArrayIterator.asSingleFqName()) return false
+    val typeArg = irType.arguments[0]
+    if (typeArg !is IrType) return false
+    return typeArg.needsMfvcFlattening()
+}
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mfvcVArrayMapping.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mfvcVArrayMapping.kt
new file mode 100644
index 0000000..6d9e623
--- /dev/null
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mfvcVArrayMapping.kt
@@ -0,0 +1,554 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.jvm
+
+import org.jetbrains.kotlin.config.JvmMfvcVArrayFlatteningScheme
+import org.jetbrains.kotlin.ir.builders.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
+import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.name.Name
+
+/**
+ * Mapping of [LeafMfvcNode] of VArray<Mfvc> element
+ *
+ * Contains information how [LeafMfvcNode] of VArray<Mfvc> maps onto element of flattened array representation
+ *
+ * @property wrapperField Field of wrapper of flattened representation which contains the leaf value
+ * @property indexInWrapperArray Index in array stored in [wrapperField] which contains the leaf value
+ * @property wrapperArrayGetFunction Array *get* function for array stored in [wrapperField]
+ * @property wrapperArraySetFunction Array *set* function for array stored in [wrapperField]
+ * @property encodeFunction Function that returns IR for encoded value, which actually stored in [wrapperField] by original leaf value
+ * @property decodeFunction Function that returns IR for decoded, original leaf value
+ */
+class MfvcVArrayMapping(
+    val wrapperField: IrFieldSymbol,
+    val indexInWrapperArray: IrExpression,
+    val wrapperArrayGetFunction: IrFunctionSymbol,
+    val wrapperArraySetFunction: IrFunctionSymbol,
+    val encodeFunction: (IrExpression, IrBuilderWithScope) -> IrExpression,
+    val decodeFunction: (IrExpression, IrBuilderWithScope) -> IrExpression
+)
+
+abstract class MfvcVArrayMapper(protected val mfvcNode: RootMfvcNode) {
+    internal abstract val wrapperField: Map<LeafType, IrFieldSymbol>
+    internal abstract val groupSizeForType: Map<LeafType, Int>
+    internal abstract val groupSizes: List<Int>
+    internal abstract val arrayConstructors: List<IrFunctionSymbol>
+    internal abstract val arrayGetFunctions: Map<LeafType, IrFunctionSymbol>
+    internal abstract val arraySetFunctions: Map<LeafType, IrFunctionSymbol>
+    internal abstract val encodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+    internal abstract val decodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+    abstract val indexOfLeafInGroup: IntArray
+
+    fun map(
+        indexInVArrayVariable: IrVariable,
+        leafIndex: Int,
+        builder: IrBlockBuilder,
+        symbols: FlatteningSymbolsHelper
+    ): MfvcVArrayMapping {
+        val leafType = LeafType.fromIrType(mfvcNode.leaves[leafIndex].type)
+
+        // Suppose Mfvc has group_size leafs that stored in the same array as given leaf.
+        // Suppose that given leaf is leaf_index-th in the set of leafs stored in that array.
+        // Then, leaf has index indexInVArrayVariable * group_size + leaf_index in that array.
+        val indexInWrapperArray = with(builder) {
+            irCallOp(
+                symbols.backendContext.irBuiltIns.intPlusSymbol,
+                symbols.backendContext.irBuiltIns.intType,
+                irCallOp(
+                    symbols.backendContext.irBuiltIns.intTimesSymbol,
+                    symbols.backendContext.irBuiltIns.intType,
+                    irGet(indexInVArrayVariable),
+                    irInt(groupSizeForType[leafType]!!)
+                ),
+                irInt(indexOfLeafInGroup[leafIndex])
+            )
+        }
+
+        return MfvcVArrayMapping(
+            wrapperField = wrapperField[leafType]!!,
+            indexInWrapperArray = indexInWrapperArray,
+            wrapperArrayGetFunction = arrayGetFunctions[leafType]!!,
+            wrapperArraySetFunction = arraySetFunctions[leafType]!!,
+            encodeFunction = encodingFunctions[leafType]!!,
+            decodeFunction = decodingFunctions[leafType]!!
+        )
+    }
+
+    fun getVArrayWrapperCreationCall(
+        vArraySize: IrExpression,
+        builder: IrBlockBuilder,
+        symbols: FlatteningSymbolsHelper,
+        saveVariable: (IrVariable) -> Unit
+    ): IrConstructorCall =
+
+        with(builder) {
+
+            val vArraySizeTempVariable = savableStandaloneVariableWithSetter(
+                expression = vArraySize,
+                origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE,
+                saveVariable = saveVariable
+            )
+
+            fun getArrayArgument(leafsOfThisTypeCount: Int, arrayCreationFunction: IrFunctionSymbol): IrExpression {
+                if (leafsOfThisTypeCount == 0) return irNull()
+                val arrayType = if (arrayCreationFunction == symbols.backendContext.irBuiltIns.arrayOfNulls)
+                    symbols.backendContext.irBuiltIns.arrayClass.typeWith(listOf(symbols.backendContext.irBuiltIns.anyNType))
+                else
+                    arrayCreationFunction.owner.returnType
+                return irCall(arrayCreationFunction, arrayType).apply {
+                    putValueArgument(
+                        0, irCallOp(
+                            context.irBuiltIns.intTimesSymbol,
+                            context.irBuiltIns.intType,
+                            irGet(vArraySizeTempVariable),
+                            irInt(leafsOfThisTypeCount)
+                        )
+                    )
+                    if (arrayCreationFunction == symbols.backendContext.irBuiltIns.arrayOfNulls) {
+                        putTypeArgument(0, symbols.backendContext.irBuiltIns.anyNType)
+                    }
+                }
+            }
+
+            val wrapperConstructorArguments = buildList {
+                groupSizes.zip(arrayConstructors).map { (groupSize, arrayConstructor) ->
+                    add(getArrayArgument(groupSize, arrayConstructor))
+                }
+                add(irGet(vArraySizeTempVariable))
+            }
+
+            return irCall(symbols.vArrayWrapperConstructor).apply {
+                wrapperConstructorArguments.forEachIndexed { index, argument ->
+                    putValueArgument(index, argument)
+                }
+            }
+        }
+}
+
+private object Names {
+    const val GET = "get"
+    const val SET = "set"
+    const val ONES = "ones"
+    const val TWOS = "twos"
+    const val FOURS = "fours"
+    const val EIGHTS = "eights"
+    const val REFS = "refs"
+    const val LONGS = "longs"
+}
+
+class FlatteningSymbolsHelper(val backendContext: JvmBackendContext) {
+
+    val bytesGetFunction = backendContext.irBuiltIns.byteArray.functionByName(Names.GET)
+    val shortsGetFunction = backendContext.irBuiltIns.shortArray.functionByName(Names.GET)
+    val intsGetFunction = backendContext.irBuiltIns.intArray.functionByName(Names.GET)
+    val longsGetFunction = backendContext.irBuiltIns.longArray.functionByName(Names.GET)
+    val refsGetFunction = backendContext.irBuiltIns.arrayClass.functionByName(Names.GET)
+
+    val bytesSetFunction = backendContext.irBuiltIns.byteArray.functionByName(Names.SET)
+    val shortsSetFunction = backendContext.irBuiltIns.shortArray.functionByName(Names.SET)
+    val intsSetFunction = backendContext.irBuiltIns.intArray.functionByName(Names.SET)
+    val longsSetFunction = backendContext.irBuiltIns.longArray.functionByName(Names.SET)
+    val refsSetFunction = backendContext.irBuiltIns.arrayClass.functionByName(Names.SET)
+
+    val byteToLong = backendContext.irBuiltIns.byteClass.functionByName("toLong")
+    val shortToLong = backendContext.irBuiltIns.shortClass.functionByName("toLong")
+    val intToLong = backendContext.irBuiltIns.intClass.functionByName("toLong")
+
+    val intToShort = backendContext.irBuiltIns.intClass.functionByName("toShort")
+    val intToChar = backendContext.irBuiltIns.intClass.functionByName("toChar")
+    val shortToInt = backendContext.irBuiltIns.shortClass.functionByName("toInt")
+
+    val longToByte = backendContext.irBuiltIns.longClass.functionByName("toByte")
+    val longToShort = backendContext.irBuiltIns.longClass.functionByName("toShort")
+    val longToInt = backendContext.irBuiltIns.longClass.functionByName("toInt")
+
+    val floatCompanion = backendContext.irBuiltIns.floatClass.owner.companionObject()!!.symbol
+    val doubleCompanion = backendContext.irBuiltIns.doubleClass.owner.companionObject()!!.symbol
+
+    val byteArrayConstructor = backendContext.irBuiltIns.byteArray.constructors.single { it.owner.valueParameters.size == 1 }
+    val shortArrayConstructor = backendContext.irBuiltIns.shortArray.constructors.single { it.owner.valueParameters.size == 1 }
+    val intArrayConstructor = backendContext.irBuiltIns.intArray.constructors.single { it.owner.valueParameters.size == 1 }
+    val longArrayConstructor = backendContext.irBuiltIns.longArray.constructors.single { it.owner.valueParameters.size == 1 }
+
+    val vArrayWrapperClass = when (backendContext.state.mfvcVArrayFlatteningScheme) {
+        JvmMfvcVArrayFlatteningScheme.PER_TYPE -> TODO("Flattening scheme is not implemented yet")
+        JvmMfvcVArrayFlatteningScheme.PER_SIZE -> backendContext.ir.symbols.vArrayWrapperPerSizeClass
+        JvmMfvcVArrayFlatteningScheme.THREE_ARRAYS -> TODO("Flattening scheme is not implemented yet")
+        JvmMfvcVArrayFlatteningScheme.TWO_ARRAYS -> backendContext.ir.symbols.vArrayWrapperTwoArrays
+    }
+
+    val vArrayWrapperIteratorStateHolderClass = when (backendContext.state.mfvcVArrayFlatteningScheme) {
+        JvmMfvcVArrayFlatteningScheme.PER_TYPE -> TODO("Flattening scheme is not implemented yet")
+        JvmMfvcVArrayFlatteningScheme.PER_SIZE -> backendContext.ir.symbols.vArrayPerSizeIteratorStateHolder
+        JvmMfvcVArrayFlatteningScheme.THREE_ARRAYS -> TODO("Flattening scheme is not implemented yet")
+        JvmMfvcVArrayFlatteningScheme.TWO_ARRAYS -> backendContext.ir.symbols.vArrayTwoArraysIteratorStateHolder
+    }
+
+    val vArrayWrapperConstructor = vArrayWrapperClass.constructors.single { it.owner.isPrimary }
+    val vArrayWrapperIteratorStateHolderConstructor = vArrayWrapperIteratorStateHolderClass.constructors.single { it.owner.isPrimary }
+
+    val vArrayGet = backendContext.irBuiltIns.vArrayClass?.functions?.single { it.owner.name == Name.identifier("get") }
+    val vArraySet = backendContext.irBuiltIns.vArrayClass?.functions?.single { it.owner.name == Name.identifier("set") }
+    val vArraySizeGetter = backendContext.irBuiltIns.vArrayClass?.getPropertyGetter("size")
+
+    val wrapperSizeField = vArrayWrapperClass.fieldByName("size")
+    val vArrayWrapperIteratorStateHolderIndexField = vArrayWrapperIteratorStateHolderClass.fieldByName("index")
+    val vArrayWrapperIteratorStateHolderArrayField = vArrayWrapperIteratorStateHolderClass.fieldByName("array")
+
+    val noSuchElementExceptionConstructor = backendContext.ir.symbols.noSuchElementException.constructors.single()
+
+    val throwableMessageGetter = backendContext.irBuiltIns.throwableClass.getPropertyGetter("message")!!
+}
+
+internal enum class LeafType {
+    BOOL, BYTE, SHORT, CHAR, INT, FLOAT, LONG, DOUBLE, REF;
+
+    companion object {
+        fun fromIrType(type: IrType) = when {
+            type.isBoolean() -> BOOL
+            type.isByte() -> BYTE
+            type.isShort() -> SHORT
+            type.isChar() -> CHAR
+            type.isInt() -> INT
+            type.isFloat() -> FLOAT
+            type.isLong() -> LONG
+            type.isDouble() -> DOUBLE
+            else -> REF
+        }
+    }
+}
+
+fun boolToByte(boolExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irIfThenElse(
+        type = symbols.backendContext.irBuiltIns.byteType,
+        condition = boolExpr,
+        thenPart = irByte(1),
+        elsePart = irByte(0)
+    )
+}
+
+fun boolToLong(boolExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irIfThenElse(
+        type = symbols.backendContext.irBuiltIns.longType,
+        condition = boolExpr,
+        thenPart = irLong(1),
+        elsePart = irLong(0)
+    )
+}
+
+fun byteToLong(byteExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.byteToLong).apply {
+        dispatchReceiver = byteExpr
+    }
+}
+
+fun shortToLong(shortExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.shortToLong).apply {
+        dispatchReceiver = shortExpr
+    }
+}
+
+fun charToLong(charExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) =
+    shortToLong(charToShort(charExpr, irBuilder, symbols), irBuilder, symbols)
+
+fun floatToLong(floatExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) =
+    intToLong(floatToInt(floatExpr, irBuilder, symbols), irBuilder, symbols)
+
+fun intToLong(intExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.intToLong).apply {
+        dispatchReceiver = intExpr
+    }
+}
+
+fun numericToBool(numericExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper, zero: IrExpression) =
+    with(irBuilder) {
+        irCallOp(
+            callee = symbols.backendContext.irBuiltIns.booleanNotSymbol,
+            type = symbols.backendContext.irBuiltIns.booleanType,
+            dispatchReceiver = irCall(symbols.backendContext.irBuiltIns.eqeqSymbol).apply {
+                putValueArgument(0, numericExpr)
+                putValueArgument(1, zero)
+            }
+        )
+    }
+
+fun byteToBool(byteExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) =
+    numericToBool(byteExpr, irBuilder, symbols, irBuilder.irByte(0))
+
+fun longToBool(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) =
+    numericToBool(longExpr, irBuilder, symbols, irBuilder.irLong(0))
+
+fun longToByte(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.longToByte).apply {
+        dispatchReceiver = longExpr
+    }
+}
+
+fun longToShort(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.longToShort).apply {
+        dispatchReceiver = longExpr
+    }
+}
+
+fun longToInt(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.longToInt).apply {
+        dispatchReceiver = longExpr
+    }
+}
+
+fun longToChar(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.intToChar).apply {
+        dispatchReceiver = longToInt(longExpr, irBuilder, symbols)
+    }
+}
+
+fun longToFloat(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) =
+    intToFloat(longToInt(longExpr, irBuilder, symbols), irBuilder, symbols)
+
+fun charToShort(charExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.intToShort).apply {
+        dispatchReceiver = irCall(symbols.backendContext.ir.symbols.charCodeGetter).apply {
+            extensionReceiver = charExpr
+        }
+    }
+}
+
+fun shortToChar(shortExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.intToChar).apply {
+        dispatchReceiver = irCall(symbols.shortToInt).apply {
+            dispatchReceiver = shortExpr
+        }
+    }
+}
+
+
+private fun floatToInt(floatExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.backendContext.ir.symbols.floatToRawBits).apply {
+        extensionReceiver = floatExpr
+    }
+}
+
+private fun intToFloat(intExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.backendContext.ir.symbols.floatFromBits).apply {
+        extensionReceiver = irGetObject(symbols.floatCompanion)
+        putValueArgument(0, intExpr)
+    }
+}
+
+private fun longToDouble(longExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.backendContext.ir.symbols.doubleFromBits).apply {
+        extensionReceiver = irGetObject(symbols.doubleCompanion)
+        putValueArgument(0, longExpr)
+    }
+}
+
+private fun doubleToLong(doubleExpr: IrExpression, irBuilder: IrBuilderWithScope, symbols: FlatteningSymbolsHelper) = with(irBuilder) {
+    irCall(symbols.backendContext.ir.symbols.doubleToRawBits).apply {
+        extensionReceiver = doubleExpr
+    }
+}
+
+class PerSizeMapper(mvfcNode: RootMfvcNode, symbols: FlatteningSymbolsHelper) : MfvcVArrayMapper(mvfcNode) {
+
+    private val onesField = symbols.backendContext.ir.symbols.vArrayWrapperPerSizeClass.fieldByName(Names.ONES)
+    private val twosField = symbols.backendContext.ir.symbols.vArrayWrapperPerSizeClass.fieldByName(Names.TWOS)
+    private val fourField = symbols.backendContext.ir.symbols.vArrayWrapperPerSizeClass.fieldByName(Names.FOURS)
+    private val eightsField = symbols.backendContext.ir.symbols.vArrayWrapperPerSizeClass.fieldByName(Names.EIGHTS)
+    private val refsField = symbols.backendContext.ir.symbols.vArrayWrapperPerSizeClass.fieldByName(Names.REFS)
+
+    override val indexOfLeafInGroup: IntArray
+    override val wrapperField: Map<LeafType, IrFieldSymbol>
+    override val groupSizeForType: Map<LeafType, Int>
+    override val groupSizes: List<Int>
+    override val arrayConstructors: List<IrFunctionSymbol>
+    override val arrayGetFunctions: Map<LeafType, IrFunctionSymbol>
+    override val arraySetFunctions: Map<LeafType, IrFunctionSymbol>
+    override val encodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+    override val decodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+
+    init {
+        var onesCount = 0;
+        var twosCount = 0;
+        var foursCount = 0;
+        var eightsCount = 0;
+        var refsCount = 0;
+        indexOfLeafInGroup = IntArray(mfvcNode.leavesCount)
+        mfvcNode.leaves.forEachIndexed { leafIndex, leaf ->
+            indexOfLeafInGroup[leafIndex] = when {
+                leaf.type.isBoolean() -> onesCount++
+                leaf.type.isByte() -> onesCount++
+                leaf.type.isChar() -> twosCount++
+                leaf.type.isShort() -> twosCount++
+                leaf.type.isInt() -> foursCount++
+                leaf.type.isFloat() -> foursCount++
+                leaf.type.isLong() -> eightsCount++
+                leaf.type.isDouble() -> eightsCount++
+                else -> refsCount++
+            }
+        }
+
+        groupSizes = listOf(onesCount, twosCount, foursCount, eightsCount, refsCount)
+
+        with(symbols) {
+            arrayConstructors = listOf(
+                byteArrayConstructor,
+                shortArrayConstructor,
+                intArrayConstructor,
+                longArrayConstructor,
+                backendContext.irBuiltIns.arrayOfNulls
+            )
+        }
+
+        wrapperField = mapOf(
+            LeafType.BOOL to onesField,
+            LeafType.BYTE to onesField,
+            LeafType.SHORT to twosField,
+            LeafType.CHAR to twosField,
+            LeafType.INT to fourField,
+            LeafType.FLOAT to fourField,
+            LeafType.LONG to eightsField,
+            LeafType.DOUBLE to eightsField,
+            LeafType.REF to refsField
+        )
+
+        groupSizeForType = mapOf(
+            LeafType.BOOL to onesCount,
+            LeafType.BYTE to onesCount,
+            LeafType.CHAR to twosCount,
+            LeafType.SHORT to twosCount,
+            LeafType.INT to foursCount,
+            LeafType.FLOAT to foursCount,
+            LeafType.LONG to eightsCount,
+            LeafType.DOUBLE to eightsCount,
+            LeafType.REF to refsCount
+        )
+
+        with(symbols) {
+            arraySetFunctions = mapOf(
+                LeafType.BOOL to bytesSetFunction,
+                LeafType.BYTE to bytesSetFunction,
+                LeafType.CHAR to shortsSetFunction,
+                LeafType.SHORT to shortsSetFunction,
+                LeafType.INT to intsSetFunction,
+                LeafType.FLOAT to intsSetFunction,
+                LeafType.LONG to longsSetFunction,
+                LeafType.DOUBLE to longsSetFunction,
+                LeafType.REF to refsSetFunction
+            )
+        }
+
+        with(symbols) {
+            arrayGetFunctions = mapOf(
+                LeafType.BOOL to bytesGetFunction,
+                LeafType.BYTE to bytesGetFunction,
+                LeafType.CHAR to shortsGetFunction,
+                LeafType.SHORT to shortsGetFunction,
+                LeafType.INT to intsGetFunction,
+                LeafType.FLOAT to intsGetFunction,
+                LeafType.LONG to longsGetFunction,
+                LeafType.DOUBLE to longsGetFunction,
+                LeafType.REF to refsGetFunction
+            )
+        }
+
+        encodingFunctions = mapOf(
+            LeafType.BOOL to { boolExpr, irBuilder -> boolToByte(boolExpr, irBuilder, symbols) },
+            LeafType.BYTE to { byteExpr, _ -> byteExpr },
+            LeafType.SHORT to { shortExpr, _ -> shortExpr },
+            LeafType.CHAR to { charExpr, irBuilder -> charToShort(charExpr, irBuilder, symbols) },
+            LeafType.INT to { intExpr, _ -> intExpr },
+            LeafType.FLOAT to { floatExpr, irBuilder -> floatToInt(floatExpr, irBuilder, symbols) },
+            LeafType.LONG to { longExpr, _ -> longExpr },
+            LeafType.DOUBLE to { doubleExpr, irBuilder -> doubleToLong(doubleExpr, irBuilder, symbols) },
+            LeafType.REF to { refExpr, _ -> refExpr }
+        )
+
+        decodingFunctions = mapOf(
+            LeafType.BOOL to { byteExpr, irBuilder -> byteToBool(byteExpr, irBuilder, symbols) },
+            LeafType.BYTE to { byteExpr, _ -> byteExpr },
+            LeafType.SHORT to { shortExpr, _ -> shortExpr },
+            LeafType.CHAR to { shortExpr, irBuilder -> shortToChar(shortExpr, irBuilder, symbols) },
+            LeafType.INT to { intExpr, _ -> intExpr },
+            LeafType.FLOAT to { intExpr, irBuilder -> intToFloat(intExpr, irBuilder, symbols) },
+            LeafType.LONG to { longExpr, _ -> longExpr },
+            LeafType.DOUBLE to { longExpr, irBuilder -> longToDouble(longExpr, irBuilder, symbols) },
+            LeafType.REF to { refExpr, _ -> refExpr }
+        )
+    }
+}
+
+class TwoArraysMapper(mvfcNode: RootMfvcNode, symbols: FlatteningSymbolsHelper) : MfvcVArrayMapper(mvfcNode) {
+
+    private val longsField = symbols.backendContext.ir.symbols.vArrayWrapperTwoArrays.fieldByName(Names.LONGS)
+    private val refsField = symbols.backendContext.ir.symbols.vArrayWrapperTwoArrays.fieldByName(Names.REFS)
+
+    override val indexOfLeafInGroup: IntArray
+    override val wrapperField: Map<LeafType, IrFieldSymbol>
+    override val groupSizeForType: Map<LeafType, Int>
+    override val groupSizes: List<Int>
+    override val arrayConstructors: List<IrFunctionSymbol>
+    override val arrayGetFunctions: Map<LeafType, IrFunctionSymbol>
+    override val arraySetFunctions: Map<LeafType, IrFunctionSymbol>
+    override val encodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+    override val decodingFunctions: Map<LeafType, (IrExpression, IrBuilderWithScope) -> IrExpression>
+
+    init {
+        var longsCount = 0;
+        var refsCount = 0;
+        indexOfLeafInGroup = IntArray(mfvcNode.leavesCount)
+        mfvcNode.leaves.forEachIndexed { leafIndex, leaf ->
+            indexOfLeafInGroup[leafIndex] = if (leaf.type.isPrimitiveType()) longsCount++ else refsCount++
+        }
+
+        groupSizes = listOf(longsCount, refsCount)
+
+        with(symbols) {
+            arrayConstructors = listOf(longArrayConstructor, backendContext.irBuiltIns.arrayOfNulls)
+        }
+
+        wrapperField = LeafType.values().associateWith { if (it == LeafType.REF) refsField else longsField }
+
+        groupSizeForType = LeafType.values().associateWith { if (it == LeafType.REF) refsCount else longsCount }
+
+        arraySetFunctions =
+            LeafType.values().associateWith { if (it == LeafType.REF) symbols.refsSetFunction else symbols.longsSetFunction }
+
+        arrayGetFunctions =
+            LeafType.values().associateWith { if (it == LeafType.REF) symbols.refsGetFunction else symbols.longsGetFunction }
+
+
+        encodingFunctions = mapOf(
+            LeafType.BOOL to { boolExpr, irBuilder -> boolToLong(boolExpr, irBuilder, symbols) },
+            LeafType.BYTE to { byteExpr, irBuilder -> byteToLong(byteExpr, irBuilder, symbols) },
+            LeafType.SHORT to { shortExpr, irBuilder -> shortToLong(shortExpr, irBuilder, symbols) },
+            LeafType.CHAR to { charExpr, irBuilder -> charToLong(charExpr, irBuilder, symbols) },
+            LeafType.INT to { intExpr, irBuilder -> intToLong(intExpr, irBuilder, symbols) },
+            LeafType.FLOAT to { floatExpr, irBuilder -> floatToLong(floatExpr, irBuilder, symbols) },
+            LeafType.LONG to { longExpr, _ -> longExpr },
+            LeafType.DOUBLE to { doubleExpr, irBuilder -> doubleToLong(doubleExpr, irBuilder, symbols) },
+            LeafType.REF to { refExpr, _ -> refExpr }
+        )
+
+        decodingFunctions = mapOf(
+            LeafType.BOOL to { longExpr, irBuilder -> longToBool(longExpr, irBuilder, symbols) },
+            LeafType.BYTE to { longExpr, irBuilder -> longToByte(longExpr, irBuilder, symbols) },
+            LeafType.SHORT to { longExpr, irBuilder -> longToShort(longExpr, irBuilder, symbols) },
+            LeafType.CHAR to { longExpr, irBuilder -> longToChar(longExpr, irBuilder, symbols) },
+            LeafType.INT to { longExpr, irBuilder -> longToInt(longExpr, irBuilder, symbols) },
+            LeafType.FLOAT to { longExpr, irBuilder -> longToFloat(longExpr, irBuilder, symbols) },
+            LeafType.LONG to { longExpr, _ -> longExpr },
+            LeafType.DOUBLE to { longExpr, irBuilder -> longToDouble(longExpr, irBuilder, symbols) },
+            LeafType.REF to { refExpr, _ -> refExpr }
+        )
+    }
+}
\ No newline at end of file
diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
index f04553a..bf2b6af 100644
--- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
+++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/descriptors/IrBuiltInsOverDescriptors.kt
@@ -478,6 +478,8 @@
                 it.descriptor.valueParameters.size == 1 && KotlinBuiltIns.isInt(it.descriptor.valueParameters[0].type)
     }
 
+    override val vArrayIteratorFunction: IrSimpleFunctionSymbol? = null // not implemented in old frontend
+
     override val linkageErrorSymbol: IrSimpleFunctionSymbol = defineOperator("linkageError", nothingType, listOf(stringType))
 
     override val enumClass = builtIns.enum.toIrSymbol()
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
index e75439d..dd4c447 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt
@@ -152,6 +152,7 @@
     abstract val arrayOfNulls: IrSimpleFunctionSymbol
 
     abstract val vArrayOfNulls: IrSimpleFunctionSymbol?
+    abstract val vArrayIteratorFunction: IrSimpleFunctionSymbol?
 
     abstract val linkageErrorSymbol: IrSimpleFunctionSymbol
 
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
index 39febc3..5e32c79 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt
@@ -340,6 +340,9 @@
 fun IrBuilderWithScope.irSamConversion(argument: IrExpression, type: IrType) =
     typeOperator(type, argument, IrTypeOperator.SAM_CONVERSION, type)
 
+fun IrBuilderWithScope.irByte(value: Byte, type: IrType = context.irBuiltIns.byteType) =
+    IrConstImpl.byte(startOffset, endOffset, type, value)
+
 fun IrBuilderWithScope.irInt(value: Int, type: IrType = context.irBuiltIns.intType) =
     IrConstImpl.int(startOffset, endOffset, type, value)
 
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
index f2bb85f..4d5d039 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/irTypePredicates.kt
@@ -39,6 +39,7 @@
     @JvmField val string = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "String")
     @JvmField val array = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "Array")
     @JvmField val vArray = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "VArray")
+    @JvmField val vArrayIterator = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "VArrayIterator")
     @JvmField val collection = getPublicSignature(StandardNames.COLLECTIONS_PACKAGE_FQ_NAME, "Collection")
     @JvmField val kClass = getPublicSignature(StandardNames.KOTLIN_REFLECT_FQ_NAME, "KClass")
     @JvmField val comparable = getPublicSignature(StandardNames.BUILT_INS_PACKAGE_FQ_NAME, "Comparable")
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt b/compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt
new file mode 100644
index 0000000..d53973c
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt
@@ -0,0 +1,35 @@
+import java.lang.StringBuilder
+
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+class PointIterator(val array: VArray<Point>) : VArrayIterator<Point> {
+    private var index: Int = 0
+
+    override fun hasNext() = index < array.size
+
+    override fun next() = array[index++]
+}
+
+fun box(): String {
+
+    val arr = VArray(2) { Point(it, it + 1) }
+
+    val it = PointIterator(arr)
+
+    val builder = StringBuilder()
+
+    while (it.hasNext()) {
+        builder.append(it.next())
+    }
+
+    if (builder.toString() != "Point(x=0, y=1)Point(x=1, y=2)") return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt b/compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt
new file mode 100644
index 0000000..00bbd9a
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt
@@ -0,0 +1,54 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(
+    val bool: Boolean,
+    val byte: Byte,
+    val short: Short,
+    val char: Char,
+    val int: Int,
+    val float: Float,
+    val long: Long,
+    val double: Double,
+    val string: String
+)
+
+@JvmInline
+value class X(val z: String, val x: VArray<Point>)
+
+fun box(): String {
+
+    val vArray = VArray(9) {
+        Point(
+            it > 0,
+            it.toByte(),
+            it.toShort(),
+            '0' + it,
+            it,
+            it.toFloat(),
+            it.toLong(),
+            it.toDouble(),
+            it.toString()
+        )
+    }
+
+    val bool = vArray[0].bool
+    val byte = vArray[1].byte
+    val short = vArray[2].short
+    val char = vArray[3].char
+    val int = vArray[4].int
+    val float = vArray[5].float
+    val long = vArray[6].long
+    val double = vArray[7].double
+    val string = vArray[8].string
+
+    val str = "$bool $byte $short $char $int $float $long $double $string"
+
+    if (str != "false 1 2 3 4 5.0 6 7.0 8") return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt
new file mode 100644
index 0000000..09a863d
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt
@@ -0,0 +1,17 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun box(): String {
+
+    val vArray2D = VArray(2) { i -> VArray(2) { j -> Point(i + j, i + j + 1) } }
+
+    if (vArray2D[1][1].y != 3) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt
new file mode 100644
index 0000000..795c2c9
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt
@@ -0,0 +1,17 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(arr: VArray<Point>) = arr[1].y
+
+fun box(): String {
+
+    if (foo(VArray(2) { Point(it, it + 1) }) != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt
new file mode 100644
index 0000000..268a984
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt
@@ -0,0 +1,17 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(arr: VArray<Point>, func: (VArray<Point>) -> Int) = func(arr)
+
+fun box(): String {
+
+    if (foo(VArray(2) { Point(it, it + 1) }) { it[1].y } != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt
new file mode 100644
index 0000000..e9c7745
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt
@@ -0,0 +1,17 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(x: Int, func: (Int) -> VArray<Point>) = func(x)[1].y
+
+fun box(): String {
+
+    if (foo(1, { x -> VArray(2) { i -> Point(i + x, i + x + 1) } }) != 3) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt
new file mode 100644
index 0000000..9c3981e
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt
@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+@JvmInline
+value class Poly(val s: Point, val points: VArray<Point>)
+
+fun box(): String {
+
+    val poly = Poly(s = Point(1, 2), points = VArray(3) { Point(it, it + 1) })
+
+    if (poly.points[2].y != 3) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt
new file mode 100644
index 0000000..82e9bd1
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt
@@ -0,0 +1,18 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+class A(val arr: VArray<Point>)
+
+fun box(): String {
+
+    val a = A(VArray(2) { Point(it, it + 1) })
+
+    if (a.arr[1].y != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt
new file mode 100644
index 0000000..8618f67
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt
@@ -0,0 +1,21 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+class A() {
+    val arr: VArray<Point> get() = VArray(2) { Point(it, it + 1) }
+}
+
+fun box(): String {
+
+    val a = A()
+
+    if (a.arr[1].y != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt
new file mode 100644
index 0000000..ddf09d4
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt
@@ -0,0 +1,18 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo() = VArray(2) { Point(it, it + 1) }
+
+
+fun box(): String {
+
+    if (foo()[1].y != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt
new file mode 100644
index 0000000..9db316d
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt
@@ -0,0 +1,25 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+@JvmInline
+value class Poly(val points: VArray<Point>)
+
+@JvmInline
+value class PolyWrapper(val poly: Poly)
+
+fun box(): String {
+
+    val poly = Poly(VArray(3) { Point(it, it + 1) })
+
+    if (poly.points[2].y != 3) return "Fail 1"
+
+    val polyWrapper = PolyWrapper(poly)
+    if (polyWrapper.poly.points[2].y != 3) return "Fail 2"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt
new file mode 100644
index 0000000..69409f7
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt
@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+
+fun box(): String {
+
+    val a = VArray(2) { Point(it, it + 1) }
+    val b = a
+    val c = b
+
+    if (c[1].y != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt
new file mode 100644
index 0000000..f42a663
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt
@@ -0,0 +1,19 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun box(): String {
+
+    VArray(2) { Point(it, it + 1) }[0] = Point(10, 20)
+
+    val a = VArray(2) { Point(it, it + 1) }[1].y
+
+    if (a != 2) return "Fail"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt
new file mode 100644
index 0000000..f8f7d7f
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt
@@ -0,0 +1,27 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(b: Boolean, x: Int): Int {
+    val vArray = if (b) {
+        val y = x + 1;
+        VArray(2) { Point(it + y, it + y + 1) }
+    } else {
+        val z = x * 2;
+        VArray(2) { Point(it + z, it + z + 1) }
+    }
+    return vArray[1].y
+}
+
+fun box(): String {
+
+    if (foo(false, 2) != 6) return "Fail 1"
+    if (foo(true, 1) != 4) return "Fail 2"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt
new file mode 100644
index 0000000..4be8a76
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt
@@ -0,0 +1,23 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(x: Int) = try {
+    1 / x
+    VArray(2) { Point(it + x, it + x + 1) }
+} catch (t: Throwable) {
+    VArray(2) { Point(it + x + 2, it + x + 3) }
+}
+
+fun box(): String {
+
+    if (foo(0)[1].y != 4) return "Fail 1"
+    if (foo(1)[1].y != 3) return "Fail 2"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt
new file mode 100644
index 0000000..5fb60eb
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt
@@ -0,0 +1,35 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun foo(c: Int, x: Int): Int {
+    val vArray = when (c) {
+        0 -> {
+            val a = x + 1
+            VArray(2) { Point(it + a, it + a + 1) }
+        }
+        1 -> {
+            val b = x + 2
+            VArray(2) { Point(it + b, it + b + 1) }
+        }
+        else -> {
+            val c = x + 3
+            VArray(2) { Point(it + c, it + c + 1) }
+        }
+    }
+    return vArray[1].y
+}
+
+fun box(): String {
+
+    if (foo(0, 1) != 4) return "Fail 1"
+    if (foo(1, 2) != 6) return "Fail 2"
+    if (foo(2, 3) != 8) return "Fail 3"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt
new file mode 100644
index 0000000..83d59af
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt
@@ -0,0 +1,36 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+inline fun <reified T> throws(block: () -> Unit): Boolean {
+    try {
+        block.invoke()
+    } catch (t: Throwable) {
+        return t is T
+    }
+    return false
+}
+
+fun box(): String {
+
+    val arr = VArray(2) { Point(it, it + 1) }
+    val it = arr.iterator()
+
+    if (!it.hasNext()) return "Fail 1"
+    if (it.next().toString() != "Point(x=0, y=1)") return "Fail 2"
+    if (!it.hasNext()) return "Fail 3"
+    if (it.next().toString() != "Point(x=1, y=2)") return "Fail 4"
+    if (it.hasNext()) return "Fail 5"
+    if (!throws<NoSuchElementException> { it.next() }) return "Fail 6"
+    if (it.hasNext()) return "Fail 6"
+    if (!throws<NoSuchElementException> { it.next() }) return "Fail 7"
+
+    // TODO: fix and check exception messages
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt b/compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt
new file mode 100644
index 0000000..2823ad0
--- /dev/null
+++ b/compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt
@@ -0,0 +1,20 @@
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// ENABLE_JVM_IR_INLINER
+// TARGET_FRONTEND: FIR
+// LANGUAGE: +ValueClasses
+
+@JvmInline
+value class Point(val x: Int, val y: Int)
+
+fun box(): String {
+
+    if (VArray(2) { Point(-1, 1) }.size != 2) return "Fail 1"
+
+    val vArray2D = VArray(2) { VArray(3) { Point(-1, 1) } }
+
+    if (vArray2D.size != 2) return "Fail 2"
+    if (vArray2D[1].size != 3) return "Fail 3"
+
+    return "OK"
+}
\ No newline at end of file
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
index 836e627..022cc27 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
+++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java
@@ -49534,6 +49534,16 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+            }
+        }
     }
 
     @Nested
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
index 2ecea47..fc779c4 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
+++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java
@@ -52198,6 +52198,124 @@
         public void testVarargParameterOfInlineType() throws Exception {
             runTest("compiler/testData/codegen/box/vArrays/varargParameterOfInlineType.kt");
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+
+            @Test
+            @TestMetadata("customIterator.kt")
+            public void testCustomIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("typesEncodings.kt")
+            public void testTypesEncodings() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt");
+            }
+
+            @Test
+            @TestMetadata("vArray2D.kt")
+            public void testVArray2D() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsFunctionParameter.kt")
+            public void testVArrayAsFunctionParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaParameter.kt")
+            public void testVArrayAsLambdaParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaReturnType.kt")
+            public void testVArrayAsLambdaReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsMfvcProperty.kt")
+            public void testVArrayAsMfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsProperty.kt")
+            public void testVArrayAsProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsPropertyNoBackingField.kt")
+            public void testVArrayAsPropertyNoBackingField() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsReturnType.kt")
+            public void testVArrayAsReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsSfvcProperty.kt")
+            public void testVArrayAsSfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayChainAssignment.kt")
+            public void testVArrayChainAssignment() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayExpression.kt")
+            public void testVArrayExpression() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInIfElseBlock.kt")
+            public void testVArrayInIfElseBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInTryBlock.kt")
+            public void testVArrayInTryBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInWhenExpr.kt")
+            public void testVArrayInWhenExpr() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayIterator.kt")
+            public void testVArrayIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("vArraySize.kt")
+            public void testVArraySize() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt");
+            }
+        }
     }
 
     @Nested
diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java
index 1b85007..88d0800 100644
--- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java
+++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java
@@ -52198,6 +52198,124 @@
         public void testVarargParameterOfInlineType() throws Exception {
             runTest("compiler/testData/codegen/box/vArrays/varargParameterOfInlineType.kt");
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true);
+            }
+
+            @Test
+            @TestMetadata("customIterator.kt")
+            public void testCustomIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/customIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("typesEncodings.kt")
+            public void testTypesEncodings() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/typesEncodings.kt");
+            }
+
+            @Test
+            @TestMetadata("vArray2D.kt")
+            public void testVArray2D() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArray2D.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsFunctionParameter.kt")
+            public void testVArrayAsFunctionParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsFunctionParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaParameter.kt")
+            public void testVArrayAsLambdaParameter() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaParameter.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsLambdaReturnType.kt")
+            public void testVArrayAsLambdaReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsLambdaReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsMfvcProperty.kt")
+            public void testVArrayAsMfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsMfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsProperty.kt")
+            public void testVArrayAsProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsPropertyNoBackingField.kt")
+            public void testVArrayAsPropertyNoBackingField() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsPropertyNoBackingField.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsReturnType.kt")
+            public void testVArrayAsReturnType() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsReturnType.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayAsSfvcProperty.kt")
+            public void testVArrayAsSfvcProperty() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayAsSfvcProperty.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayChainAssignment.kt")
+            public void testVArrayChainAssignment() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayChainAssignment.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayExpression.kt")
+            public void testVArrayExpression() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayExpression.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInIfElseBlock.kt")
+            public void testVArrayInIfElseBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInIfElseBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInTryBlock.kt")
+            public void testVArrayInTryBlock() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInTryBlock.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayInWhenExpr.kt")
+            public void testVArrayInWhenExpr() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayInWhenExpr.kt");
+            }
+
+            @Test
+            @TestMetadata("vArrayIterator.kt")
+            public void testVArrayIterator() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArrayIterator.kt");
+            }
+
+            @Test
+            @TestMetadata("vArraySize.kt")
+            public void testVArraySize() throws Exception {
+                runTest("compiler/testData/codegen/box/vArrays/mfvc/vArraySize.kt");
+            }
+        }
     }
 
     @Nested
diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
index 830e3fa..197d866 100644
--- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
+++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java
@@ -40321,6 +40321,19 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
         }
+
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Mfvc extends AbstractLightAnalysisModeTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true);
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/valueClasses")
diff --git a/core/builtins/native/kotlin/VArray.kt b/core/builtins/native/kotlin/VArray.kt
index ef67a65..30d6af6 100644
--- a/core/builtins/native/kotlin/VArray.kt
+++ b/core/builtins/native/kotlin/VArray.kt
@@ -5,6 +5,7 @@
 
 package kotlin
 
+// TODO: add 'reified' to T
 class VArray<T> {
     public operator fun get(index: Int): T
     public operator fun set(index: Int, value: T): Unit
diff --git a/core/builtins/src/kotlin/VArrayIterator.kt b/core/builtins/src/kotlin/VArrayIterator.kt
index d695344..6d2486e 100644
--- a/core/builtins/src/kotlin/VArrayIterator.kt
+++ b/core/builtins/src/kotlin/VArrayIterator.kt
@@ -7,4 +7,5 @@
 
 interface VArrayIterator<T> : Iterator<T> {
     override fun next(): T
+    override fun hasNext(): Boolean
 }
\ No newline at end of file
diff --git a/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt b/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt
index 6ea3445..cbec8eb 100644
--- a/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt
+++ b/core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt
@@ -37,6 +37,7 @@
     val Annotation = "Annotation".baseId()
     val Array = "Array".baseId()
     val VArray = "VArray".baseId()
+    val vArrayIterator = "VArrayIterator".baseId()
 
     val Boolean = "Boolean".baseId()
     val Char = "Char".baseId()
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java
index a2b6193d..96a5753 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java
@@ -36906,6 +36906,16 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true);
+            }
+        }
     }
 
     @Nested
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java
index 1746282..9d02b8e 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java
@@ -37248,6 +37248,16 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+            }
+        }
     }
 
     @Nested
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java
index 8d4db39..03cf91f70 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java
@@ -37248,6 +37248,16 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true);
+            }
+        }
     }
 
     @Nested
diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java
index 78975f5..02c0bba 100644
--- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java
+++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java
@@ -37248,6 +37248,16 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true);
         }
+
+        @Nested
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        public class Mfvc {
+            @Test
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true);
+            }
+        }
     }
 
     @Nested
diff --git a/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/ArrayIterator.kt b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/ArrayIterator.kt
index 1cf47a7..4972e41 100644
--- a/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/ArrayIterator.kt
+++ b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/ArrayIterator.kt
@@ -11,6 +11,7 @@
     override fun next() = try { array[index++] } catch (e: ArrayIndexOutOfBoundsException) { index -= 1; throw NoSuchElementException(e.message) }
 }
 
+// TODO: add 'reified' to T
 public class VArrayIteratorImpl<T>(val array: VArray<T>) : VArrayIterator<T> {
     private var index = 0
     override fun hasNext() = index < array.size
diff --git a/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayIteratorStateHolders.kt b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayIteratorStateHolders.kt
new file mode 100644
index 0000000..93034e0
--- /dev/null
+++ b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayIteratorStateHolders.kt
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.jvm.internal
+
+class VArrayPerSizeIteratorStateHolder(@JvmField val array: VArrayWrapperPerSize, @JvmField var index: Int)
+
+class VArrayTwoArraysIteratorStateHolder(@JvmField val array: VArrayWrapperTwoArrays, @JvmField var index: Int)
\ No newline at end of file
diff --git a/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayWrappers.kt b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayWrappers.kt
new file mode 100644
index 0000000..a08c07a
--- /dev/null
+++ b/libraries/stdlib/jvm/runtime/kotlin/jvm/internal/VArrayWrappers.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package kotlin.jvm.internal
+
+import kotlin.jvm.JvmField
+
+class VArrayWrapperPerSize(
+    @JvmField val ones: ByteArray?,
+    @JvmField val twos: ShortArray?,
+    @JvmField val fours: IntArray?,
+    @JvmField val eights: LongArray?,
+    @JvmField val refs: Array<Any?>?,
+    @JvmField val size: Int
+)
+
+class VArrayWrapperTwoArrays(
+    @JvmField val longs: LongArray?,
+    @JvmField val refs: Array<Any?>?,
+    @JvmField val size: Int
+)
\ No newline at end of file
diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java
index fb79699..386a8db 100644
--- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java
+++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java
@@ -41446,6 +41446,20 @@
             public void testAllFilesPresentInVArrays() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
             }
+
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+            @TestDataPath("$PROJECT_ROOT")
+            @Tag("codegenK2")
+            @Tag("firCodegen")
+            @UseExtTestCaseGroupProvider()
+            @FirPipeline()
+            public class Mfvc {
+                @Test
+                public void testAllFilesPresentInMfvc() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
+                }
+            }
         }
 
         @Nested
diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java
index b48d779..6b8551f 100644
--- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java
+++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestNoPLGenerated.java
@@ -42472,6 +42472,22 @@
             public void testAllFilesPresentInVArrays() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
             }
+
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+            @TestDataPath("$PROJECT_ROOT")
+            @Tag("codegenK2")
+            @Tag("firCodegen")
+            @UseExtTestCaseGroupProvider()
+            @FirPipeline()
+            @UsePartialLinkage(mode = Mode.DISABLED)
+            @Tag("no-partial-linkage-may-be-skipped")
+            public class Mfvc {
+                @Test
+                public void testAllFilesPresentInMfvc() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
+                }
+            }
         }
 
         @Nested
diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java
index feb7967..56f1f91 100644
--- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java
+++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java
@@ -40933,6 +40933,19 @@
             public void testAllFilesPresentInVArrays() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
             }
+
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+            @TestDataPath("$PROJECT_ROOT")
+            @Tag("codegen")
+            @Tag("k1Codegen")
+            @UseExtTestCaseGroupProvider()
+            public class Mfvc {
+                @Test
+                public void testAllFilesPresentInMfvc() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
+                }
+            }
         }
 
         @Nested
diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java
index 4c1b9dc..8f00d69 100644
--- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java
+++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestNoPLGenerated.java
@@ -41959,6 +41959,21 @@
             public void testAllFilesPresentInVArrays() throws Exception {
                 KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
             }
+
+            @Nested
+            @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+            @TestDataPath("$PROJECT_ROOT")
+            @Tag("codegen")
+            @Tag("k1Codegen")
+            @UseExtTestCaseGroupProvider()
+            @UsePartialLinkage(mode = Mode.DISABLED)
+            @Tag("no-partial-linkage-may-be-skipped")
+            public class Mfvc {
+                @Test
+                public void testAllFilesPresentInMfvc() throws Exception {
+                    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true);
+                }
+            }
         }
 
         @Nested
diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java
index a59da49..817f6c1 100644
--- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java
+++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java
@@ -33271,6 +33271,19 @@
         public void testAllFilesPresentInVArrays() throws Exception {
             KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true);
         }
+
+        @TestMetadata("compiler/testData/codegen/box/vArrays/mfvc")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Mfvc extends AbstractIrCodegenBoxWasmTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInMfvc() throws Exception {
+                KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vArrays/mfvc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true);
+            }
+        }
     }
 
     @TestMetadata("compiler/testData/codegen/box/valueClasses")