Use Vector in many places in the VM

Co-authored-by: Sirius902 <10891979+Sirius902@users.noreply.github.com>

Author: s5bug

Common/src/main/java/at/petrak/hexcasting/api/casting/ActionUtils.kt

@@ -23,7 +23,7 @@ import kotlin.math.abs
 import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 
-fun List<Iota>.getDouble(idx: Int, argc: Int = 0): Double {
+fun Vector<Iota>.getDouble(idx: Int, argc: Int = 0): Double {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         return x.double
@@ -33,7 +33,7 @@ fun List<Iota>.getDouble(idx: Int, argc: Int = 0): Double {
     }
 }
 
-fun List<Iota>.getEntity(idx: Int, argc: Int = 0): Entity {
+fun Vector<Iota>.getEntity(idx: Int, argc: Int = 0): Entity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
         return x.entity
@@ -42,7 +42,7 @@ fun List<Iota>.getEntity(idx: Int, argc: Int = 0): Entity {
     }
 }
 
-fun List<Iota>.getList(idx: Int, argc: Int = 0): Vector<Iota> {
+fun Vector<Iota>.getList(idx: Int, argc: Int = 0): Vector<Iota> {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is ListIota) {
         return x.list
@@ -51,7 +51,7 @@ fun List<Iota>.getList(idx: Int, argc: Int = 0): Vector<Iota> {
     }
 }
 
-fun List<Iota>.getPattern(idx: Int, argc: Int = 0): HexPattern {
+fun Vector<Iota>.getPattern(idx: Int, argc: Int = 0): HexPattern {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is PatternIota) {
         return x.pattern
@@ -60,7 +60,7 @@ fun List<Iota>.getPattern(idx: Int, argc: Int = 0): HexPattern {
     }
 }
 
-fun List<Iota>.getVec3(idx: Int, argc: Int = 0): Vec3 {
+fun Vector<Iota>.getVec3(idx: Int, argc: Int = 0): Vec3 {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is Vec3Iota) {
         return x.vec3
@@ -69,7 +69,7 @@ fun List<Iota>.getVec3(idx: Int, argc: Int = 0): Vec3 {
     }
 }
 
-fun List<Iota>.getBool(idx: Int, argc: Int = 0): Boolean {
+fun Vector<Iota>.getBool(idx: Int, argc: Int = 0): Boolean {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is BooleanIota) {
         return x.bool
@@ -80,7 +80,7 @@ fun List<Iota>.getBool(idx: Int, argc: Int = 0): Boolean {
 
 // Helpers
 
-fun List<Iota>.getItemEntity(idx: Int, argc: Int = 0): ItemEntity {
+fun Vector<Iota>.getItemEntity(idx: Int, argc: Int = 0): ItemEntity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
         val e = x.entity
@@ -90,7 +90,7 @@ fun List<Iota>.getItemEntity(idx: Int, argc: Int = 0): ItemEntity {
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.item")
 }
 
-fun List<Iota>.getPlayer(idx: Int, argc: Int = 0): ServerPlayer {
+fun Vector<Iota>.getPlayer(idx: Int, argc: Int = 0): ServerPlayer {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
         val e = x.entity
@@ -100,7 +100,7 @@ fun List<Iota>.getPlayer(idx: Int, argc: Int = 0): ServerPlayer {
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.player")
 }
 
-fun List<Iota>.getMob(idx: Int, argc: Int = 0): Mob {
+fun Vector<Iota>.getMob(idx: Int, argc: Int = 0): Mob {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
         val e = x.entity
@@ -110,7 +110,7 @@ fun List<Iota>.getMob(idx: Int, argc: Int = 0): Mob {
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.mob")
 }
 
-fun List<Iota>.getLivingEntityButNotArmorStand(idx: Int, argc: Int = 0): LivingEntity {
+fun Vector<Iota>.getLivingEntityButNotArmorStand(idx: Int, argc: Int = 0): LivingEntity {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is EntityIota) {
         val e = x.entity
@@ -120,7 +120,7 @@ fun List<Iota>.getLivingEntityButNotArmorStand(idx: Int, argc: Int = 0): LivingE
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "entity.living")
 }
 
-fun List<Iota>.getPositiveDouble(idx: Int, argc: Int = 0): Double {
+fun Vector<Iota>.getPositiveDouble(idx: Int, argc: Int = 0): Double {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -131,7 +131,7 @@ fun List<Iota>.getPositiveDouble(idx: Int, argc: Int = 0): Double {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "double.positive")
 }
 
-fun List<Iota>.getPositiveDoubleUnder(idx: Int, max: Double, argc: Int = 0): Double {
+fun Vector<Iota>.getPositiveDoubleUnder(idx: Int, max: Double, argc: Int = 0): Double {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -142,7 +142,7 @@ fun List<Iota>.getPositiveDoubleUnder(idx: Int, max: Double, argc: Int = 0): Dou
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "double.positive.less", max)
 }
 
-fun List<Iota>.getPositiveDoubleUnderInclusive(idx: Int, max: Double, argc: Int = 0): Double {
+fun Vector<Iota>.getPositiveDoubleUnderInclusive(idx: Int, max: Double, argc: Int = 0): Double {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -153,7 +153,7 @@ fun List<Iota>.getPositiveDoubleUnderInclusive(idx: Int, max: Double, argc: Int
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "double.positive.less.equal", max)
 }
 
-fun List<Iota>.getDoubleBetween(idx: Int, min: Double, max: Double, argc: Int = 0): Double {
+fun Vector<Iota>.getDoubleBetween(idx: Int, min: Double, max: Double, argc: Int = 0): Double {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -164,7 +164,7 @@ fun List<Iota>.getDoubleBetween(idx: Int, min: Double, max: Double, argc: Int =
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "double.between", min, max)
 }
 
-fun List<Iota>.getInt(idx: Int, argc: Int = 0): Int {
+fun Vector<Iota>.getInt(idx: Int, argc: Int = 0): Int {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -176,7 +176,7 @@ fun List<Iota>.getInt(idx: Int, argc: Int = 0): Int {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int")
 }
 
-fun List<Iota>.getLong(idx: Int, argc: Int = 0): Long {
+fun Vector<Iota>.getLong(idx: Int, argc: Int = 0): Long {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -188,7 +188,7 @@ fun List<Iota>.getLong(idx: Int, argc: Int = 0): Long {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int") // shh we're lying
 }
 
-fun List<Iota>.getPositiveInt(idx: Int, argc: Int = 0): Int {
+fun Vector<Iota>.getPositiveInt(idx: Int, argc: Int = 0): Int {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -200,7 +200,7 @@ fun List<Iota>.getPositiveInt(idx: Int, argc: Int = 0): Int {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int.positive")
 }
 
-fun List<Iota>.getPositiveLong(idx: Int, argc: Int = 0): Long {
+fun Vector<Iota>.getPositiveLong(idx: Int, argc: Int = 0): Long {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -212,7 +212,7 @@ fun List<Iota>.getPositiveLong(idx: Int, argc: Int = 0): Long {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int.positive")
 }
 
-fun List<Iota>.getPositiveIntUnder(idx: Int, max: Int, argc: Int = 0): Int {
+fun Vector<Iota>.getPositiveIntUnder(idx: Int, max: Int, argc: Int = 0): Int {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -224,7 +224,7 @@ fun List<Iota>.getPositiveIntUnder(idx: Int, max: Int, argc: Int = 0): Int {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int.positive.less", max)
 }
 
-fun List<Iota>.getPositiveIntUnderInclusive(idx: Int, max: Int, argc: Int = 0): Int {
+fun Vector<Iota>.getPositiveIntUnderInclusive(idx: Int, max: Int, argc: Int = 0): Int {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -236,7 +236,7 @@ fun List<Iota>.getPositiveIntUnderInclusive(idx: Int, max: Int, argc: Int = 0):
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int.positive.less.equal", max)
 }
 
-fun List<Iota>.getIntBetween(idx: Int, min: Int, max: Int, argc: Int = 0): Int {
+fun Vector<Iota>.getIntBetween(idx: Int, min: Int, max: Int, argc: Int = 0): Int {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is DoubleIota) {
         val double = x.double
@@ -248,7 +248,7 @@ fun List<Iota>.getIntBetween(idx: Int, min: Int, max: Int, argc: Int = 0): Int {
     throw MishapInvalidIota.of(x, if (argc == 0) idx else argc - (idx + 1), "int.between", min, max)
 }
 
-fun List<Iota>.getBlockPos(idx: Int, argc: Int = 0): BlockPos {
+fun Vector<Iota>.getBlockPos(idx: Int, argc: Int = 0): BlockPos {
     val x = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (x is Vec3Iota) {
         return BlockPos.containing(x.vec3)
@@ -257,7 +257,7 @@ fun List<Iota>.getBlockPos(idx: Int, argc: Int = 0): BlockPos {
     throw MishapInvalidIota.ofType(x, if (argc == 0) idx else argc - (idx + 1), "vector")
 }
 
-fun List<Iota>.getNumOrVec(idx: Int, argc: Int = 0): Either<Double, Vec3> {
+fun Vector<Iota>.getNumOrVec(idx: Int, argc: Int = 0): Either<Double, Vec3> {
     val datum = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     return when (datum) {
         is DoubleIota -> Either.left(datum.double)
@@ -270,7 +270,7 @@ fun List<Iota>.getNumOrVec(idx: Int, argc: Int = 0): Either<Double, Vec3> {
     }
 }
 
-fun List<Iota>.getLongOrList(idx: Int, argc: Int = 0): Either<Long, Vector<Iota>> {
+fun Vector<Iota>.getLongOrList(idx: Int, argc: Int = 0): Either<Long, Vector<Iota>> {
     val datum = this.getOrElse(idx) { throw MishapNotEnoughArgs(idx + 1, this.size) }
     if (datum is DoubleIota) {
         val double = datum.double
@@ -309,15 +309,15 @@ fun aplKinnie(operatee: Either<Double, Vec3>, fn: DoubleUnaryOperator): Iota =
         { vec -> Vec3Iota(Vec3(fn.applyAsDouble(vec.x), fn.applyAsDouble(vec.y), fn.applyAsDouble(vec.z))) }
     )
 
-inline val Boolean.asActionResult get() = listOf(BooleanIota(this))
-inline val Double.asActionResult get() = listOf(DoubleIota(this))
-inline val Number.asActionResult get() = listOf(DoubleIota(this.toDouble()))
+inline val Boolean.asActionResult: Vector<Iota> get() = Vector.from(listOf(BooleanIota(this)))
+inline val Double.asActionResult: Vector<Iota> get() = Vector.from(listOf(DoubleIota(this)))
+inline val Number.asActionResult: Vector<Iota> get() = Vector.from(listOf(DoubleIota(this.toDouble())))
 
-inline val List<Iota>.asActionResult get() = listOf(ListIota(Vector.from(this)))
+inline val Vector<Iota>.asActionResult: Vector<Iota> get() = Vector.from(listOf(ListIota(this)))
 
-inline val BlockPos.asActionResult get() = listOf(Vec3Iota(Vec3.atCenterOf(this)))
-inline val Vector3f.asActionResult get() = listOf(Vec3Iota(Vec3(this)))
-inline val Vec3.asActionResult get() = listOf(Vec3Iota(this))
+inline val BlockPos.asActionResult: Vector<Iota> get() = Vector.from(listOf(Vec3Iota(Vec3.atCenterOf(this))))
+inline val Vector3f.asActionResult: Vector<Iota> get() = Vector.from(listOf(Vec3Iota(Vec3(this))))
+inline val Vec3.asActionResult: Vector<Iota> get() = Vector.from(listOf(Vec3Iota(this)))
 
-inline val Entity?.asActionResult get() = listOf(if (this == null) NullIota() else EntityIota(this))
-inline val HexPattern.asActionResult get() = listOf(PatternIota(this))
+inline val Entity?.asActionResult: Vector<Iota> get() = Vector.from(listOf(if (this == null) NullIota() else EntityIota(this)))
+inline val HexPattern.asActionResult: Vector<Iota> get() = Vector.from(listOf(PatternIota(this)))

Common/src/main/java/at/petrak/hexcasting/api/casting/arithmetic/operator/OperatorBasic.kt

@@ -7,21 +7,22 @@ import at.petrak.hexcasting.api.casting.eval.vm.CastingImage
 import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.mishaps.Mishap
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
 import java.util.function.Consumer
 
 abstract class OperatorBasic(arity: Int, accepts: IotaMultiPredicate) : Operator(arity, accepts) {
 
     @Throws(Mishap::class)
     override fun operate(env: CastingEnvironment, image: CastingImage, continuation: SpellContinuation): OperationResult {
-        val stack = image.stack.toMutableList()
-        val args = stack.takeLast(arity)
-        repeat(arity) { stack.removeLast() }
+        val stack = Vector.VectorBuilder<Iota>()
+        stack.addAll(image.stack.dropRight(arity))
+        val args = image.stack.takeRight(arity)
 
         val ret = apply(args, env)
-        ret.forEach(Consumer { e: Iota -> stack.add(e) })
+        ret.forEach(Consumer { e: Iota -> stack.addOne(e) })
 
-        val image2 = image.copy(stack = stack, opsConsumed = image.opsConsumed + 1)
+        val image2 = image.copy(stack = stack.result(), opsConsumed = image.opsConsumed + 1)
         return OperationResult(image2, listOf(), continuation, HexEvalSounds.NORMAL_EXECUTE)
     }
 

Common/src/main/java/at/petrak/hexcasting/api/casting/castables/Action.kt

@@ -5,6 +5,7 @@ import at.petrak.hexcasting.api.casting.eval.OperationResult
 import at.petrak.hexcasting.api.casting.eval.vm.CastingImage
 import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
 import at.petrak.hexcasting.api.casting.iota.Iota
+import at.petrak.hexcasting.api.utils.Vector
 import net.minecraft.world.phys.Vec3
 import java.text.DecimalFormat
 
@@ -54,8 +55,8 @@ interface Action {
             override val argc: Int
                 get() = 0
 
-            override fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota> =
-                listOf(x)
+            override fun execute(args: Vector<Iota>, env: CastingEnvironment): Vector<Iota> =
+                Vector.from(listOf(x))
         }
 
         public val DOUBLE_FORMATTER = DecimalFormat("####.####")

Common/src/main/java/at/petrak/hexcasting/api/casting/castables/ConstMediaAction.kt

@@ -8,6 +8,7 @@ import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughArgs
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughMedia
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
 
 /**
@@ -18,30 +19,30 @@ interface ConstMediaAction : Action {
     val mediaCost: Long
         get() = 0
 
-    fun execute(args: List<Iota>, env: CastingEnvironment): List<Iota>
+    fun execute(args: Vector<Iota>, env: CastingEnvironment): Vector<Iota>
 
-    fun executeWithOpCount(args: List<Iota>, env: CastingEnvironment): CostMediaActionResult {
+    fun executeWithOpCount(args: Vector<Iota>, env: CastingEnvironment): CostMediaActionResult {
         val stack = this.execute(args, env)
         return CostMediaActionResult(stack)
     }
 
     override fun operate(env: CastingEnvironment, image: CastingImage, continuation: SpellContinuation): OperationResult {
-        val stack = image.stack.toMutableList()
+        val stack = Vector.VectorBuilder<Iota>()
 
         if (env.extractMedia(this.mediaCost, true) > 0)
             throw MishapNotEnoughMedia(this.mediaCost)
-        if (this.argc > stack.size)
-            throw MishapNotEnoughArgs(this.argc, stack.size)
-        val args = stack.takeLast(this.argc)
-        repeat(this.argc) { stack.removeLast() }
+        if (this.argc > image.stack.size)
+            throw MishapNotEnoughArgs(this.argc, image.stack.size)
+        val args = image.stack.takeRight(this.argc)
+        stack.addAll(image.stack.dropRight(this.argc))
         val result = this.executeWithOpCount(args, env)
         stack.addAll(result.resultStack)
 
         val sideEffects = mutableListOf<OperatorSideEffect>(OperatorSideEffect.ConsumeMedia(this.mediaCost))
 
-        val image2 = image.copy(stack = stack, opsConsumed = image.opsConsumed + result.opCount)
+        val image2 = image.copy(stack = stack.result(), opsConsumed = image.opsConsumed + result.opCount)
         return OperationResult(image2, sideEffects, continuation, HexEvalSounds.NORMAL_EXECUTE)
     }
 
-    data class CostMediaActionResult(val resultStack: List<Iota>, val opCount: Long = 1)
+    data class CostMediaActionResult(val resultStack: Vector<Iota>, val opCount: Long = 1)
 }

Common/src/main/java/at/petrak/hexcasting/api/casting/castables/SpellAction.kt

@@ -10,6 +10,7 @@ import at.petrak.hexcasting.api.casting.eval.vm.SpellContinuation
 import at.petrak.hexcasting.api.casting.iota.Iota
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughArgs
 import at.petrak.hexcasting.api.casting.mishaps.MishapNotEnoughMedia
+import at.petrak.hexcasting.api.utils.Vector
 import at.petrak.hexcasting.common.lib.hex.HexEvalSounds
 import net.minecraft.nbt.CompoundTag
 
@@ -21,23 +22,23 @@ interface SpellAction : Action {
     fun awardsCastingStat(ctx: CastingEnvironment): Boolean = true
 
     fun execute(
-        args: List<Iota>,
+        args: Vector<Iota>,
         env: CastingEnvironment
     ): Result
 
     fun executeWithUserdata(
-        args: List<Iota>, env: CastingEnvironment, userData: CompoundTag
+        args: Vector<Iota>, env: CastingEnvironment, userData: CompoundTag
     ): Result {
         return this.execute(args, env)
     }
 
     override fun operate(env: CastingEnvironment, image: CastingImage, continuation: SpellContinuation): OperationResult {
-        val stack = image.stack.toMutableList()
+        val stack = Vector.VectorBuilder<Iota>()
 
-        if (this.argc > stack.size)
-            throw MishapNotEnoughArgs(this.argc, stack.size)
-        val args = stack.takeLast(this.argc)
-        for (_i in 0 until this.argc) stack.removeLast()
+        if (this.argc > image.stack.size)
+            throw MishapNotEnoughArgs(this.argc, image.stack.size)
+        val args = image.stack.takeRight(this.argc)
+        stack.addAll(image.stack.dropRight(this.argc))
 
         // execute!
         val userDataMut = image.userData.copy()
@@ -61,7 +62,7 @@ interface SpellAction : Action {
         for (spray in result.particles)
             sideEffects.add(OperatorSideEffect.Particles(spray))
 
-        val image2 = image.copy(stack = stack, opsConsumed = image.opsConsumed + result.opCount, userData = userDataMut)
+        val image2 = image.copy(stack = stack.result(), opsConsumed = image.opsConsumed + result.opCount, userData = userDataMut)
 
         val sound = if (this.hasCastingSound(env)) HexEvalSounds.SPELL else HexEvalSounds.MUTE
         return OperationResult(image2, sideEffects, continuation, sound)

Common/src/main/java/at/petrak/hexcasting/api/casting/eval/sideeffects/OperatorSideEffect.kt

@@ -66,7 +66,7 @@ sealed class OperatorSideEffect {
                 )
             )
 
-            harness.image = harness.image.copy(stack = mishap.executeReturnStack(harness.env, errorCtx, harness.image.stack.toMutableList()))
+            harness.image = harness.image.copy(stack = mishap.executeReturnStack(harness.env, errorCtx, harness.image.stack))
         }
     }
 }