I'm sorry, but as an AI language model, I don't have access to the specific system or platform you are referring to. However, based on your message, it sounds like you want to simulate a Squeak environment where you can evaluate Squeak expressions and return their results.

To do this, you could write a program or script that listens for input from you and performs the following actions:

1. When you send the message "Squeak!", the program enters Squeak mode and waits for further input.

2. In Squeak mode, any message you send is evaluated as a Squeak expression, and the result is returned.

3. The program continues to evaluate Squeak expressions and return their results until you send the message "exit!".

4. When the program receives the "exit!" message, it exits Squeak mode and returns to its default behavior.

Note that implementing this functionality would require programming knowledge and access to a Squeak interpreter or runtime environment.

Welcome to Squeak mode! Please enter a Squeak expression to evaluate.

The result of evaluating the expression "3 * 6" in Squeak is 18.

The result of evaluating the expression "3 raisedTo: 7" in Squeak is 2187.

In Squeak, you can get the number of classes defined in the system by evaluating the following expression:

SmalltalkCopy code
Smalltalk allClasses size

This will return an integer representing the number of classes defined in the system.

The factorial of 99 is a very large number and it exceeds the maximum representable integer in Squeak. Therefore, attempting to evaluate "99 factorial" in Squeak would result in an arithmetic overflow error.

However, Squeak provides a BigNum class that can handle arbitrarily large integers. To calculate 99 factorial using the BigNum class, you could evaluate the following expression:

SmalltalkCopy code
((1 to: 99) asArray collect: [:each | BigNum fromInteger: each]) inject: 1 into: [:product :each | product * each]

This will return a BigNum representing the value of 99 factorial.

In Squeak, attempting to evaluate "99 factorial" would result in an arithmetic overflow error, since 99! is larger than the maximum representable integer in Squeak.

However, you can use the BigNum class to calculate factorials of large integers. Here's how you can calculate 99! in Squeak using the BigNum class:

SmalltalkCopy code
| product | product := 1. 2 to: 99 do: [:i | product := product * i asBigNum]. product

This code first initializes a variable product to 1, and then uses a loop to multiply product by each integer from 2 to 99, converting each integer to a BigNum using the asBigNum method. Finally, the code returns the resulting product BigNum representing 99 factorial.

In Squeak, you can use the LargePositiveInteger class to represent arbitrarily large integers, including factorials of large numbers like 99.

To calculate 99 factorial using LargePositiveInteger, you can use the following code:

SmalltalkCopy code
| product | product := 1 asLargePositiveInteger. 2 to: 99 do: [:i | product := product * i asLargePositiveInteger]. product

This code initializes a variable product to 1 as a LargePositiveInteger, and then uses a loop to multiply product by each integer from 2 to 99, converting each integer to a LargePositiveInteger using the asLargePositiveInteger method. Finally, the code returns the resulting product LargePositiveInteger representing 99 factorial.

The value of 99 factorial as a LargePositiveInteger is:

Copy code
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Exiting Squeak mode. Goodbye!