This tutorial is set by the author's setting without permission.

It is explained in advance that my Java level is very poor. I imitate the Tectech source code below in the way of seeing C ++. If you find any errors, please point out in the comment area.

Related source code part: source code

I found some related functions and methods and classes:

 Public Static void Run () {// 20K Heat Cap Max!

New Rackcomponent (itemlist.circuit_primitive.get (1), 1, 4, 0, 500, true); // Primitive Circuit
New RackComponent (itemlist.circuit_basic.get (1), 4, 8, 0, 1000, true); // Basic Circuit
New rackcomponent (itemlist.circuit_microprocessor.get (1), 6, 8, 0, 1250, true);
New rackcomponent (itemlist.circuit_good.get (1), 6, 9, -.05F, 1500, true); // Good Circuit
New RackComponent (itemlist.circuit_integrated_good.get (1), 7, 9, -.075f, 1750, true); TRUE); TRUE)
New RackComponent (itemlist.circuit_prcessor.get (1), 8, 9, -.07F, 1800, TRUE);
New RackComponent (itemlist.circuit_parts_advanced.get (1), 1, 2, -.05F, 2000, TRUE); True); True); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE);
New RackComponent (itemlist.circuit_nanoprocessor.get (1), 8, 10, -.09f, 2250, true); // Advanced Circuit
New RackComponent (itemlist.circuit_advanced.get (1), 8, 10, -.1F, 2500, TRUE);
New RackComponent (itemlist.circuit_data.get (1), 9, 1, -.1F, 3000, TRUE); // Ev Circuit New Rackcomponent (itmlist.circuComputer.get (1), 1) 11, 10, -.125F, 3300, True);
New Rackcomponent (itemlist.circuit_quantumProcessor.get (1), 13, 10, -.15F, 3600, TRUE);
New rackcomponent (itemlist.circuit_elite.get (1), 12, 10, -.15f, 3500, true); // Iv Circuit
New RackComponent (itemlist.circuit_elitenanocomputer.get (1), 14, 10, -.15F, 4000, TRUE); TRUE); TRUE);
New RackComponent (itemlist.circuit_quantumcomPuter.get (1), 16, 10, -.15F, 4500, TRUE);
New Rackcomponent (itemlist.circuit_crystalProcessor.get (1), 18, 10, -.15f, 5000, true);
New rackcomponent (itemlist.circuit_master.get (1), 16, 12, -.2F, 5000, true); // Luv Circuit
New Rackcomponent (itemlist.circuit_masterquantumcomPuter.get (1), 16, 13, -2F, 5100, TRUE);
New RackComponent (itemlist.circuit_crystalcomPuter.get (1), 20, 14, -25F, 5200, TRUE); TRUE); TRUE);
New RackComponent (itemlist.circuit_neuroprocessor.get (1), 24, 15, -.3F, 5300, TRUE);
New RackComponent (itemlist.circuit_quantummianframe.get (1), 22, 14, -.3F, 5200, TRUE); // zpm city new rackcomponent (itemlist.circuit_ult_ult_ult_ult_ult ImateCrystalComputer.get (1), 26, 16, -.3F, 5400, 5400, True);
New RackComponent (itemlist.circuit_wetwarecomputer.get (1), 30, 18, -.3F, 5600, TRUE);
New RackComponent (itemlist.circuit_crystalmainframe.get (1), 30, 18, -.35F, 5500, TRUE); // uv Circuit
New Rackcomponent (itemlist.circuit_wetwareSupercomputer.get (1), 35, 22, -.3F, 5700, TRUE));
New RackComponent (itemlist.circuit_wetwareMainframe.get (1), 38, 25, -.4F, 6000, TRUE); // uhv circuit
New RackComponent ("IC2: IC2.Reactorvent", 0, -1, 10F, 1000, False);
New Rackcomponent ("IC2: IC2.ReaCTORVENTCORE", 0, -1, 20F, 2500, False);
New Rackcomponent ("IC2: IC2.ReaCTORVENTGOLD", 0, -1, 40F, 5000, FALSE);
New RackComponent ("IC2: IC2.ReaCTORVENTDIAMOND", 0, -1, 80F, 10000, FALSE); // 2x OC
Ifader.ismodloaded (reference.dreamCraft) {{
// GTNH-GT5U CIRCUITS
// TheSe Components Cases Crashhes When used with the Original GT5U New Rackcomponent (itemlist.nandchip.get (1), 2, 6, 0, 750, True); // Primiti ve circuit
New RackComponent (itemlist.circuit_biowarecomputer.get (1), 40, 26, -.35F, 5900, TRUE);
New RackComponent (itemlist.circuit_biowaresuperComputer.get (1), 42, 30, -.4F, 6200, TRUE);
New RackComponent (itemlist.circuit_biomainframe.get (1), 44, 28, -.4F, 6000, TRUE); // Uev Circuit
New RackComponent (itemlist.circuit_bioprocessor.get (1), 34, 20, -.35F, 5800, TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE) of
New Rackcomponent ("DreamCraft: Item.highenergyCircuitParts", 3, 2, -.1F, 9001, TRUE);
New RackComponent ("DreamCraft: Item.highenergyflowCircuit", 24, 16, -.25F, 10000, TRUE); TRUE); TRUE); TRUE)
New RackComponent ("DreamCraft: Item.nanocircuit", 50, 35, -.45F, 8000, TRUE);
New RackComponent ("DreamCraft: Item.pikocircuit", 64, 40, -.5F, 8500, TRUE);
New RackComponent ("DreamCraft: Item.quantumCircuit", 128, 48, -.6F, 9000, TRUE);}
Ifader.ismodloaded (reference.spartakcore) {{
// Customgt5u Circuits
// The COMPONENTS CAUSES CRASHES WIED With the Original GT5U
New rackcomponent (itemlist.nandchip.get (1), 2, 6, 0, 750, true); // Primitive Circuit
New RackComponent (itemlist.circuit_biowarecomputer.get (1), 40, 26, -.35F, 5900, TRUE);
New RackComponent (itemlist.circuit_biowaresuperComputer.get (1), 42, 30, -.4F, 6200, TRUE);
New RackComponent (itemlist.circuit_biomainframe.get (1), 40, 28, -.4F, 6000, TRUE); // uhv circuit
New RackComponent (itemlist.circuit_bioprocessor.get (1), 34, 20, -.35F, 5800, TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE); TRUE) of
}
Ifader.ismodloaded ("OpenComputers") {{) {{) {
New Rackcomponent ("OpenComputers: Item.oc.transistor", 0, 1, 0F, 100, True); // Transistor
new RackComponent("OpenComputers:item.oc.Microchip0", 7, 12, -.05f, 1500, true); // chip t1        new RackComponent("OpenComputers:item.oc.Microchip1", 18, 20, -.1f, 3000, true); // Chip T2
New Rackcomponent ("OpenComputers: Item.oc.Microchip2", 25, 22, -.15F, 4500, TRUE); // Chip T3
New Rackcomponent ("OpenComputers: item.oc.alu", 10, 15, -.05F, 3000, TRUE); // Alu
New RackComponent ("OpenComputers: Item.oc.controlunit", 25, 18, -.05F, 1500, TRUE); // Cu
New Rackcomponent ("OpenComputers: item.oc.comPonentbus0", 42, 30, -.05F, 1500, TRUE); // Bus T1
New Rackcomponent ("OpenComputers: item.oc.comPonentbus1", 70, 50, -.1F, 3000, TRUE); // Bus T2
New RackComponent ("OpenComputers: item.oc.comPonentbus2", 105, 72, -.15f, 4500, true); // bus t3
New Rackcomponent ("OpenComputers: Item.oc.cpu0", 106, 73, -1F, 1500, TRUE); // CPU T1
New RackComponent ("OpenComputers: item.oc.cpu1", 226, 153, -15F, 3000, TRUE); // CPU T2 New Rackcomponent ("OpenComputers: Item.oc.cpu2" ", 374, 241, -.2F, 4500, true); // CPU T3
New Rackcomponent ("OpenComputers: Item.oc.graphicsCard0", 20, 27, -.1F, 1500, TRUE); // GPU T1
New Rackcomponent ("OpenComputers: Item.oc.graphicsCard1", 62, 67, -.2F, 3000, TRUE); // GPU T2
New Rackcomponent ("OpenComputers: Item.oc.graphicsCard2", 130, 111, -.3F, 4500, TRUE); // GPU T3
New Rackcomponent ("OpenComputers: Item.oc.apu0", 350, 234, -1F, 1500, TRUE); // APU T2
New Rackcomponent ("OpenComputers: Item.oc.apu1", 606, 398, -.2F, 4500, TRUE); // APU T3
New Rackcomponent ("OpenComputers: Item.oc.apu2", 1590, 1006, -.3F, 9000, TRUE); // APU TC
}
}
Public Static Class Rackcomponent Implements Comparable  {
Private Final String UnLocalizedName; Private Final Float Heat, Coeff, Computation, Maxheat;
Private Final Boolean Subzero;
Rackcomponent (itemstack is, float computation, float heat, float coeff, float maxheat, boolean subzero) {{
This (GetuniqueIdentifier (is), Computation, Heat, Coeff, Maxheat, Subzero);
}
Rackcomponent (String is, Float Computation, Float Heat, Float Coeff, Float Maxheat, Boolean Subzero) {{
UnlocalizedName = is;
This.heat = heat;
This.Coeff = coeff;
This.comPutation = computation;
This.maxheat = maxheat;
This.subzero = Subzero;
Componentbinds.put (unlocalizedName, this);
If (debug_mode) {
Tectech.logger.info ("Component RegisterEd:"+UnlocalizedName);
}
}
@Override Public Int Compareto (Rackcomponent O) {{
Return University.
}
@Override
Public Boolean Equals (Object Obj) {
If (Obj Instanceofu Rackcomponent) {
Return compareto (rackcomponent) == 0;
}
Return false;
}
} 

After analyzing the RackComponent as a class, it refers to a component that can be placed in a quantum computer case. The class contains the non -localized name of the item, the heat production (Heat), and the COEFF.Maxheat, Subzero has not seen what it means for the time being, but the Subzero of the object created is all True, and the actual calculation has nothing to do with Subzero's True and FALSE.

Next, find the method of calculating computing power:

 Private Int GetComputationPower (Float OverClock, Float Overvolt, Boolean Tickingcomponents) {

Float Computation = 0, Heat = 0;
For (int i = 0; I 
If (minventory [i] == null || minventory [i] .stacksize! = 1) {
Continue;
}
RackcomponENENT Comp = Componentbinds.get (GetuniqueIdifier (MINVENTORY [i])); if (comp == null) {{
Continue;
}
If (TickingComponents) {
If (this.heat> Comp.maxheat) {{
Minventory [i] = null;
Continue;
} Else if (comp.subzero || this.heat> = 0) {{{
Heat+= (1F+Comp.coeff*this.heat/10000F)
*(Comp.heat> 0? Comp.heat*OverClock*OverClock*Overvolt: Comp.heat);
If (overvolt*10F> 7F+Tectech.random.nextFloat () {) {) {) {) {) {) {) {) {
Computation+= comp.comPutation*math.max (
0,
Math.min (
Math.min (OverClock, Overvolt+Overvolt-0.25),
1+Tectech.random.nextFloat ()+(Overvolt-1)-(OverClock-1)/2);
}
}
} Else {Computation+= Comp.comPutation*Overclock;
}
}
If (TickingComponents) {
This.heat+= math.ceil (head);
}
Return (int) math.floor (computation);
}
@Override
Public int Getinventorystacklimit () {) {
Return 1;
}
public int tickcomponents (float OC, Float OV) {{
If (OC> 3+Tectech.random.nextFloat () || OV> 2+Tectech.random.nextFloat () {) {) {) {) {) {) {) {) {) {)
GetBasemetatilentity (). Settofire ();
}
OverClock = OC;
Overvolt = OV;
Return getComputationPower (overClock, overvolt, true);
} 

Note that when running normally, the parameter passed to getComputationPower TickingComponents is true.

Tectech.random.nextFloat () method is a random floating point number of (0,1.0).

Convert the code into a natural language: overclocking time multiple> 3 or overclocking voltage multiple> 2, the machine will burn.

All components in a single chassis per second. First of all, the calorie ΔHeat changes to the computer case:

For a single component, the amount of calories of the case Δheat = (the thermal efficiency of the 1+ component*(current heat/10000))*ψ

产 Variables are related to whether the component produces heat

If the component is hot, 组 = component heat production*[(overclocking time multiple)^2]*(overclocking voltage multiple)

If the component does not produce heat, 组 = component heat production heat

In fact, for the category of heat dissipation films, component heat production is negative value

Theoretically, the total calories change amount δ δ δ δ δ = σ (i = 1,4) (1+ thermal efficiency (i)*Current heat/10000)*ψ (i)

In fact, the upward value of σΔheat is the calories of real changes

Then the amount of computing power provides:

First judge the size relationship between overclocking voltage voltage multiples*10 and 7+σ (the random floating point between σ is (0,1.0)):

If the overclocking voltage multiples*10> 7+σ

Define α1 = min (overclocking time multiple, 2*overclocking voltage multiple -0.25)

α2 = 1+++(overclocking voltage multiple-1)-(overclocking time multiple -1)/2 (random floating point between ρ (0,1.0)) α3 = min (α1, α2)

α4 = max (α3,0)

The theoretical output computing power = the sum of the computing power provided by all internal components*α4.

The actual output computing power should be collected downward.

It is explained here that if you do not overclocking, the overclocking voltage multiple is 1, the overclocking time multiple is 1, and the computing power is the sum of the computing power provided by all components inside.

In addition, the quantum computer case will naturally heat the heat:

Natural heat dissipation involves the following methods:

@outerride

Public Void OnPosttick
If (ABASEMETATILEENTITY.ISSERVERSIDE ()) {) {
If (atick%20 == multi_check_at) {{
If (heat> 0) {{
Float heatc = 0;
For (int i = 0; I 
If (minventory [i] == null || minventory [i] .stacksize! = 1) {
Constinue;
}
RackcomponENENT Comp = Componentbinds.get (GetuniqueIdifier (MINVENTORY [i]));
If (comp == null) {Continue;
}
Ift> Comp.maxheat) {
Minventory [i] = null;
} Else if (comp.head <0) {{
Headc+= comp.head*(heat/10000F);
}
}
Head+= math.max (-heat, math.ceil (heatc));
}
If (heat> 0) {{
Head- = math.max (heat/1000, 1);} else if (heat <0) {
Heat- = math.min (heat/1000, -1);
}
Ift> 10000) {
Abasemetatilentity.settofire ();
} Else if (heat> 9000) {
Abasemetatilentity.Setonfire ();
} Else if (heat <-10000) {
Heat = -10000;
}
}
}
} 

Natural heat dissipation involves two steps:

Step 1: First of all, traverse all the heat dissipation components in the case, heat change amount ΔHeatc = component heat production*Current heat/10000

The first step in the calories is MAX (-current heat, ΔHeatc takes up)

After the first step of heat changes:

If heat> 0

The second step of the calories change is -max (head/1000,1)

If heat <0

The second step The calories change is -min (heat.1000, -1)

After understanding the principle, from the code of generating objects from the RackcomPonent class, you can know the nature of the corresponding component. Note that it is to calculate the computing power and calories, then calculate the natural heat dissipation, and pay attention to the order of calculation.

There are two ways to judge whether a certain design is feasible:

The first: Establish the iterative formula of the Heat (T+1) = f (Heat (T)), and find that the iterative conditions of the GuassSidel are found to determine whether the coefficient matrix is ​​strict or symmetrical, and it can determine whether it converge.However, the disadvantage is that the amount of calculation is large, and it still needs to calculate the stable heat and the most valuable value, because the component has the upper limit of the allowable calories, and the component must not be damaged.The second type: directly establish a cubic equation and find the Heat value of stable time. This calculation is faster, but it cannot be determined whether the temperature rises to higher than heat before falling. It may cause components to damage the component.

The following is the C ++ source code used for the auxiliary calculation. It is feasible to calculate whether the calculation of overclocking and non -overclocking is feasible: (Forgot to mention it earlier, OverClock is greater than 3 or overvolt greater than 2, the machine will directly fire!)

#Include 

#include 
#include 
#include 
#include 
#include 
using namespace std;
#Define OK 1
#Define Broken 0
#Define GreaterthanthemaximumValue -1
#Define Smallerthantheminimum Value-1
class component {
Private:
Float heat;
Float Coeff;
Float maxheat;
Float Computation;
BOOL DESTROYED;
Public:
Void setdata (float a, float b, float c, float d) {{
This-> heat = a;
This-> coeff = b;
This-> maxheat = C;
This-> computation = d;
This-> Destroyed = false;
}
Float Getheat () {) {
Return this-> heat;
}
Float getcoeff () {
Return this-> coeff;
}
Float getmaxheat () {Return this-> maxheat;
}
Float getComputation () {
Return this-> Computation;
}
BOOL getstatus () {
Return this-> Destroyed;
}
Void outputdata () {
Printf ("Data from this component:
Generate heat:%f, thermal efficiency:%f, the maximum calories that can be withstand:%f, the computing power provided:%f, whether%f has been damaged:%f
", this-> heat, this-> coeff, this-> maxheat, this-> computation, this-> desroyed);
}
};
class quantumcomPute {
Public:
Component array [4];
Private:
Int Maxheat;
Int nowheat;
Int componentnumber;
Int outputComputation;
Float overvolt;
Float OverClock;
Public:
Void setmaxheat (int a) {
This-> maxheat = a;
}
Void Setnowheat (int a) {
This-> Nowheat = a;
}
Int getnowheat () {) {)
Return this-> Nowheat;
}
Float getovervolt () {
Return this-> Overvolt;}
Float getoverClock () {{)
Return this-> OverClock;
}
Int getoutPutComputation () {
Return this-> outputComputation;
}
Void Initialization (Int Number, Float Overvolt, Float OverClock) {{
For (int i = 0; i <4; i ++) {
This-> Array [i] .setdata (0,0,10000,0);
}
This-> componentnumber = number;
This-> Nowheat = 0;
This-> maxheat = 10000;
This-> outputComputation = 0;
This-> overClock = overClock;
This-> overvolt = overvolt;
}
Void getComponentdata () {
Float Num1, NUM2, NUM3, Num4;
For (int i = 0; I  Componentnumber; I ++) {scanf ("%f%f%f%f", & num1, & num2, & num3, & num4);
This-> array [i] .setdata (num1, num2, num3, num4);
If (this-> overClock == 1 && this-> Overvolt == 1) {{
This-> outputComputation = this-> OutputComputation+(int) this-> Array [i] .getComputation ();
}
// Printf ("%D
", this-> outputComputation);
}
}
Void PrintComponentdata () {
For (int i = 0; i <4; i ++) {
This-> array [i] .outputdata ();
}
}
Void CalccomputationPowerantheat () {) {) {) {) {) {) {)
If (this-> overClock == 1 && this-> Overvolt == 1) {{
Float Changeheat1 = 0;
For (int i = 0; i <4; i ++) {
Changeheat1 = Changeheat1+((Float) 1+this-> Array [i] .getCoeff ()*this-> Nowhead/(float) 10000)*(this-> Array [i] .Getheat ());}
Int Change = 0;
Change = Ceil (Changeheat1);
This-> Nowheat = this-> Nowheat+Change;
// Printf ("Current heat:%D
", this-> Nowheat);
} Else {
// The program that is not finished
// Printf ("Nowheat:%D
", this-> Nowheat);
Srand ((unsigned) (time (0));
// this-> outputComputation = 0;
Float Randomnumber1 = Static_Cast  (RAND ())/Static_Cast  (RAND_MAX);;
Float F1 = min (this-> overClock, (Float) 2*this-> Overvolt- (float) 0.25);
Float F2 = (Float) 1+RANDOMNUMBER1+(this-> Overvolt- (Float) 1)-(this-> Overclock- (Float)/Float (2));
Float F4 = Max ((Float) 0, F3);
// Printf ("F4:%F
", f4);
Float Tempout = 0;
For (int i = 0; i <4; i ++) {
Tempout = tempout+f4*this-> Array [i] .getComputation ();
}
This-> outputComputation = Floor (Tempout);
Float Changeheat1 = 0;
For (int i = 0; i <4; i ++) {
If (this-> Array [i] .Getheat ()> 0) {{{
Changeheat1 = Changeheat1+(this-> Array [i] .Getheat ()*this-> Overclo CK*This-> Overclock*this-> Overvolt)*((Float) 1+this-> Array [i] .get Coeff ()*this-> Nowheat/(Float) 10000);} Else if (this-> Array [i] .Getheat () <0) {
Changeheat1 = Changeheat1+(this-> Array [i] .Getheat ())*((Float) 1+This-> Array [I] .getCoeff ()*This-> Nowhead/(Float) 10000);
}
}
Int Change = 0;
Change = Ceil (Changeheat1);
// Printf ("Change:%D
", Change);
This-> Nowheat = this-> Nowheat+Change;
// Printf ("Nowheat:%D
", this-> Nowheat);
}
}
Void naturheatdissipation () {{) {
Float Changeheat2 = 0;
If (this-> nowheat> 0) {{
For (int i = 0; i <4; i ++) {if (this-> array [i] .Getheat () <0) {
CHANGEHEAT2 = Changeheat2+this-> Array [i] .Getheat ()*this-> Nowheat/(float) 10000;
} Else {
Continue;
}
}
}
// Printf ("Data:%F", Changheat2);
Int Temp1 = Ceil (Changeheat2);
Int NatureChange = 0;
Naturchange = max (-This-> Nowhead, Temp1);
This-> Nowheat = this-> Nowheat+naturalchange;
If (this-> nowheat> 0) {{
This-> Nowheat = this-> Nowheat-max (this-> nowheat/1000,1);
} Else if (this-> Nowheat <0) {{
This-> Nowheat = this-> Nowheat-min (this-> Nowheat/1000, -1);}
If (this-> Nowheat <-10000) {
This-> Nowheat = -10000;
}
// Printf ("Current heat:%D
", this-> Nowheat);
}
Int getComponentstatus () {
For (int i = 0; i <4; i ++) {
If (this-> Array [i] .getmaxheat () <(float) this- >| This-> Nowheat> this-> maxheat) {{
Return Broken;
}
}
If (this-> Nowheat> 10000) {
Return Broken;
} Else {
Return OK;
}
}
};
int Main () {
Int judge = 0;
While (true) {
Printf ("Input 1 Start the computing program, enter 0 to exit the computing program
");
Scanf ("%d", & judge); if (judge == 0) {
Return 0;
} Else if (judge == 1) {{
Int Componentnum;
Printf ("Please enter the number of components inside:
");
Scanf ("%d", & componentnum);
Printf ("Please enter overclocking voltage level and overclocking time level:
");
Float overClock, overvolt;
Scanf ("%F%F", & Overvolt, & OverClock);
If (overvolt <0.8) {{
Printf ("error! Unstable computing power provides!
");
Continue;
} Else if (overClock> 3 || Overvolt> 2) {{
Printf ("Wrong! The machine will be burned!
");
}
Printf ("Please enter the attributes of the component in order of heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, maximum heat efficiency, and maximum heat efficiency.
");
QuantumcomComputer*acomputer = new quantumcomPuter;
ACOMPUTER-> Initialization (Componentnum, Overvolt, OverClock);
ACOMPUTER-> getComponentData ();
// ACOMPUTER-> PrintComponentData (); int Status = 1;
Int Tempdata1;
Int Tempdata2;
For (int j = 0; j <6000; j ++) {
AComputer-> CalccomputationPowerandheat ();
If (j%2 == 0) {{
Tempdata1 = ACOMPUTER-> Getnowheat ();
} Else if (j%2 == 1) {{
Tempdata2 = ACOMPUTER-> Getnowheat ();
}
Status = ACOMPUTER-> getComponentstatus ();
If (Status == 0) {{
Printf ("The chassis is overheated and melted!
");
Free (AComputer);
Break;
}
If (Tempdata1 == Tempdata2) {
Printf ("This way of placement is safe!
"); PRINTF (" Charm chassis is stable time when stable:%D
", tempdata1);
Printf ("provided computing power:%D
", ACOMPUTER-> GetOutputComputation ());
Free (AComputer);
Break;
}
Acomputer-> naturheatdissipation ();
}
}
}
}