cst.close()
			}
			return true
		}

		if _, err := cst.c.Get(cst.ts.URL); err != nil {
			if tooShort(err) {
				continue
			}
			t.Fatalf("got error: %s", err)
		}

		time.Sleep(10 * timeout)
		if _, err := cst.c.Get(cst.ts.URL); err != nil {
			if tooShort(err) {
				continue
			}
			t.Fatalf("got error: %s", err)
		}
	}
}

            type.isShort -> KaConstantValue.KaShortConstantValue((value as Number).toShort(), expression)
            type.isUShort -> KaConstantValue.KaUnsignedShortConstantValue((value as Number).toShort().toUShort(), expression)
            type.isInt -> KaConstantValue.KaIntConstantValue((value as Number).toInt(), expression)

            ConstantValueKind.Long -> (value as Number).toLong()
            ConstantValueKind.Short -> (value as Number).toShort()
            ConstantValueKind.UnsignedByte -> (value as Number).toLong().toUByte()
            ConstantValueKind.UnsignedShort -> (value as Number).toLong().toUShort()
            ConstantValueKind.UnsignedInt -> (value as Number).toLong().toUInt()

        writeInt(`val`)
    }

    override fun writeBoolean(`val`: Boolean) = record {
        writeBoolean(`val`)
    }

    override fun writeShort(`val`: Int) = record {
        this.writeShort(`val`.toShort())
    }

    override fun writeLong(`val`: Long) = record {
        writeLong(`val`)
    }

    override fun writeFloat(`val`: Float) = record {
        this.writeFloat(`val`)
    }

                isBoolean -> "false"
                isUnit -> "Unit"
                isString -> "\"\""
                isUInt -> "0.toUInt()"
                isULong -> "0.toULong()"
                isUShort -> "0.toUShort()"
                isUByte -> "0.toUByte()"
                else -> null
            }
        }
}

public typealias KtTypeInfoProviderMixIn = KaTypeInfoProviderMixIn

        is ULongValue -> KaConstantValue.KaUnsignedLongConstantValue(value.toULong(), sourcePsi = null)
        is UShortValue -> KaConstantValue.KaUnsignedShortConstantValue(value.toUShort(), sourcePsi = null)
        else -> error("Unexpected constant value $value")
    }
}

internal tailrec fun KotlinBuiltIns.areSameArrayTypeIgnoringProjections(left: KotlinType, right: KotlinType): Boolean {