Remapping the Rover MEMS3 ECU

Jonathan Kay · April 3, 2020

:-)

Jonathan

revilla · April 3, 2020

Haha very good!

I've been doing some more development work. I've got both MPI and VVC ECUs popping and crackling nicely. There's just one more table that needs to be modified to make the effect persistent. It's not that it does it when cold and stops when warm as I first thought, with the ignition timing change alone it pops and crackles for a short time after startup and then stops, whether the engine is hot or cold, probably when it switches off the starting map settings to main map.

The only problem is I know which table but I don't fully understand exactly what it is doing and how to read it yet. It looks to be a time profile of the overrun behaviour. And probably driving fuelling. The more I play with it the more sense it is making. I'd like to understand it a bit better before telling you to change it.

The other issue is that it varies between maps a lot more than most of the other tables, which gives my automatic table matching code a bit of a run for its money. It struggles to find the table in an ECU where it looks very different to ones it has seen before. Got some ideas on that too though.

Will get back to you once I've got to the bottom of it, probably with slightly updated software too.

Andrew

john milner · April 4, 2020

All connected up and a copy of the map taken. The instructions worked perfectly as I just followed them word for word. Drivers for the cable were easy to apply but complicated by the wrong instructions.

IACV or VVC is ticking slowly and no fuel pump. Most likely all down to inertia switch being disconnected as I hadn’t done anything other than turn the ignition switch on. Cigarette lighter voltmeter read 12.6V.

Flasher file took a good couple of minutes to download but MAP file was seconds.

VIN has 160 on the end which perhaps indicates the BHP.

Firmware dated 1/1/1988.

Part variant:ECP123456

The Acceleration Retard Map & RPM is only less than 0 at high pressure and lowish revs. I notice that these are different from the sample files so I am wondering if Caterham had a factory tweak for this ECU in 2003.

I’m thinking that at 900rpm that it might be a good idea to keep the original values to lessen the risk of rear ending something but that changing it at 2500rpm to all 0 should boost the response during overtaking.

This next one reads to me as though the ignition is retarded when the engine gets up to temperature. So for at 75C it does nothing to the retard map but when up to temperature reduces the values by 200% (overheating protection?). Probably some weird maths going on there as unlikely in the previous table that -20 would get turned into -60.

An explanation of why averaging the 75kPa and 95 kPa values is a good idea would be useful. I can see why different values are optimal for different conditions so I don’t understand why change to an average.

A very nice piece of software. I'll leave it a couple of days before I change anything but unfortunately longer before I road test.

revilla · April 4, 2020

Hi John,

Glad to hear it all worked.

Any chance you could send me a copy of your map so I can have a good look over it (just for my own interest and learning) please? I'll drop you a BM with my email address. It's hard to read the numbers on some of the pictures due to this site's resolution restrictions.

Yes it looks like Caterham may have already tweaked that map a bit to sharpen it up. Part variant ECP123456 does denote a Caterham map.

I don't think taking out the acceleration retard effect will have you rear-ending anyone, it's not that dramatic but it does make the car feel a quite a bit sharper - but in your case it looks like the Caterham map has already taken a lot of it out so how much difference you will feel I'm not sure.

As far as I can tell, the two "Acceleration Retard" factors are roughly multiplied together, so it's not that the engine is overall more retarded at higher temperatures, more that the response-deadening effect is reduced at lower temperatures (so it doesn't really kick in until the engine is warmed up). The 200% is therefore 200% of the values in the other table - or at least roughly so. I'm having to fathom all of this out from scratch, mostly by playing with my engine in the garage whilst hooked up to oscilloscopes so I'm focusing on a "working model" which is a close enough approximation to what the ECU is actually doing inside to mean that you can change the numbers assuming it's accurate and get the results you expect. How the ECU's own code is processing some of these tables may be different from my approximation.

The averaging of the values is a bit unscientific; I did some rolling road checks a while back with numbers that were closer to the average all round, and there's also some "seat of the pants" feel and on-road tests with a decent performance meter, and it feels like it has more mid-range torque that way, but it won't be a big difference; once you have confidence with writing changes back you can play around and see what you think. The only way to really know for sure would be to do a back-to-back on the rolling road to see what was genuinely giving the best performance.

Before you make any changes for pop and crackle, check back with me (unless I've already posted an update). There is one other table you need to change to get a proper effect that lasts more than a short while after starting the engine. I haven't fully got my head around it yet; I know what numbers to put in it to get what I want from looking at a range of other modified maps and I know the effect thay have, but on a detailed technical level I'm not quite sure what they are driving yet. I might not be able to fully fathom it out until I'm able to drive on the road again, but in the meantime I can give you some numbers for it that should work nicely. It's discussed here: https://www.lotus7.club/forum/techtalk/wacky-mems3-ecu-table-any-ideas

Cheers,

Andrew

revilla · April 11, 2020

Recently added the following tables and scalars. My initial post at the top of this thread has been updated with all my latest findings too, as has the software available through the download links. I've taken to marking items which still need further research with “®” for “Research”. I'm only including features in the public release where I've got a pretty good idea what they are and how they work, but as you will see there are still some details to be tied down. There are a large number of tables where I have some clues but as these are still so speculative I've kept them back for now.

Est. Exhaust Gas Temperature - This table provides estimated values for the exhaust gas temperature.

http://andrewrevill.co.uk/MEMS3Mapper_files/image093.png

I believe some vehicles were provisioned with an exhaust gas temperature sensor at the catalytic converter to allow EGT feedback control and this table may supply estimated values when this sensor is not present or has failed.
Est. Inlet Air Temperature. ® - This table provides estimated values for the inlet air temperature.

http://andrewrevill.co.uk/MEMS3Mapper_files/image087.jpg

The values in this table are not used directly as the estimated inlet air temperature values when the inlet air temperature sensor is disconnected or has failed, but they do heavily drive the calculation. More work is required to fully understand the calculations being performed here.

NB: This table is marked with “®” for “Research” as I still need to fully understand it.
Overrun Pop & Crackle ® - This table seems to markedly affect the overrun once the ECU is off its starting map.

http://andrewrevill.co.uk/MEMS3Mapper_files/image109.jpg

If you just make the ignition timing changes in the Ignition Timing table described above, you will find that the car produces a lot of pops and crackles when first started (both hot and cold) but that these effects stop abruptly after a short period of running.

Unfortunately due to current conditions I have been unable to take the car out on the road to analyse exactly what this table is controlling, and it is impossible to hold sustained overrun conditions with the car stationary in the garage. As soon as conditions allow I will get to the bottom of this table and write it up more fully.

In the meantime, in order to produce sustained pop and crackle effects, I suggest entering numbers of the order of 50-60 in all rows except the last, and all columns except the lowest RPM. Something like this should work nicely:

http://andrewrevill.co.uk/MEMS3Mapper_files/image111.jpg

You will find the form of this table varies enormously between different stock MG Rover maps, but the advice given above on modifying the values seems to work well in most cases.

NB: This table is marked with “®” for “Research” as I still need to track down precise what it controls. Currently unsure of the meaning of the Y and Z axis values.
Ignition Dwell Time ® - This table determines the ignition dwell time for a given RPM and battery voltage.

http://andrewrevill.co.uk/MEMS3Mapper_files/image113.jpg

The ignition dwell time is the time (here in milliseconds) for which the ignition coils are turned on and “charged” with current, before being turned off and releasing all their stored energy as a high voltage spark.

The ignition coils are inductors and so when a steady voltage is applied across them, the current through them rises linearly. They also have some resistance; you can think of the resistance element as being a resistor in series with the pure ideal inductance of the coil. As the current rises, Ohm’s law tells us that the voltage across the resistance will rise, leaving less voltage across the inductance and therefore the rate of rise of the current ramp tails off. At some point the coil will saturate; at this point the voltage dropped across the resistance matches the applied voltage and so there is zero voltage remaining to drive the current ramp, and the current remains constant. In this condition, all of the power being delivered into the coil is being dissipated as heat and no more energy is being stored in the coil in a form which contributes to the spark.

Setting a dwell time which is too high will therefore just lead to excess heat in the coil packs and consequent damage. Setting a dwell time which is too low will lead to less current in the coil pack at the point where the spark is generated, therefore less energy in the spark. The spark will burn for a shorter time and at high loads ignition misfires may occur. At higher RPMs there is less time between firing events and so the dwell time has to be restricted. As there are more firing events per second the amount of heat energy dissipated in the coil packs will also increase and the dwell time may have to be limited to avoid coil damage through overheating.

The most obvious feature of this table though is the fact that the dwell time rises as the battery supply voltage falls. As the voltage falls, the rate at which the primary current builds up falls in proportion, and therefore a long dwell time is required in order to ramp the current up to the required value to generate an optimal spark.

As the timing of the ignition events (which occur at the point when the coil is turned off at the end of the dwell time) is a critical parameter for engine performance, the ECU cannot simply turn the coil on and then turn it off when the current reaches the desired level. It must know fairly accurately in advance how long it will take the primary current to ramp up to the desired level, and then it can begin the dwell period an appropriate time before the desired time of the ignition event. This table gives the ECU that critical information.

Hint: Some people have converted EU2 engines to EU3 wasted spark by using coil packs from other engines, rather than replacing the cam cover and using the regular Rover EU3 coil packs. In these cases the dwell times may not be optimal for the coils used and this table will allow them to be tuned.
Injector Dead Time ® – This table adjusts the injector pulse widths to compensate for battery and supply voltage changes.

http://andrewrevill.co.uk/MEMS3Mapper_files/image117.jpg

The magnetic force to open the injector depends upon the current flowing, but electrically the injector is basically an inductor (in series with a small resistance) and for an inductor the current changes at a rate dependent on the applied voltage; so the higher the voltage applied to the injector the faster the current builds to the value needed to open the injector.

This results in a significant “dead time” for the injector which needs to be added to time the injector is actually required to be open for when calculating the pulse width, and this dead time correction is strongly dependent on the battery voltage. At lower voltages, larger compensations are required. Without these compensations, the engine would tend to run lean mixtures when the battery voltage was low or electrical loads were high.

From initial testing the numbers in this table don’t seem to be simple additive adjustments; they appear to be non-linear with some element of a percentage of the injector pulse width. This seems illogical as the dead time only occurs as the injector opens (and to a lesser extent, closes), so should not depend on the time it spends open in between.

NB: This table is marked with “®” for “Research” as I still need to track down the precise meaning of the numbers on the Z axis.
Injector Flow Rate ® - This table gives the flow rate for the injectors as a function of battery and supply voltage.

http://andrewrevill.co.uk/MEMS3Mapper_files/image119.jpg

The flow rate for the injectors is slightly affected by supply voltage due to the finite “softness” of the response of the fuel pressure regulator and the increased performance (fuel delivery rate) of the fuel pump at higher supply voltages.

NB: This table is marked with “®” for “Research” as I still need to track down the precise meaning of the numbers on the Z axis.
Sensor Calibration (OTS) ® - This table maps the voltage measured at the oil temperature sensor (where fitted) onto an actual temperature value.

http://andrewrevill.co.uk/MEMS3Mapper_files/image127.jpg

The temperature sensing circuit inside the ECU consists of a stabilised 5V supply in series with a 1.8 kOhm resistor. This forms a potential divider to ground with the temperature sensor. The voltage at the ECU terminal is then measured with a 10-bit analogue to digital converter (on a scale 0..1023). The value returned by the converter is then looked up on the X axis of this table, with the Z axis reading off the actual temperature. I have scaled the axes to read directly in Volts and °C.

Hint: If at some point in the future temperature sensors for these engines become hard to find, this table would allow you to remap to the ECU to match pretty much any standard sensor.

NB: This table is marked with “®” for “Research” as I still need to confirm that this is the correct calibration.
Overrun Fuel Cut Min Coolant Temp. 1 & 2 – These appear to set the minimum coolant temperature at which overrun fuel cut operates. They are always set to the same value, which is by default normally 75°C. Increasing these to 140°C allows overrun fuel cut to be effectively disabled.

NB: These scalars are marked with " ®” for “Research” as I still need to verify that they have exactly the effect described.

revilla · April 14, 2020

Some more insights. Still picking away at it.

Catalyst Heating Ignition Retard ® - This table appears to define an ignition retard which is applied at mid-range RPM and MAPs for a short period after first starting the engine only.

http://andrewrevill.co.uk/MEMS3Mapper_files/image089.png

NB: The chart Z axis is correctly labelled as Ignition Advance; the numbers in this table are negative, and a negative advance is a retard.

This may be for driveability but as it seems to apply for a very short time and is not apparently driven by coolant temperature, my best understanding of this is that it is for the purposes of heating the catalytic converter rapidly. Retarded ignition timing causes hotter exhaust gas temperatures and so this retard effects dumps a large amount of heat into the exhaust system when the engine is started. Certainly when I was first digging into this effect and extended it down to idle RPMs the exhaust headers seemed to get very hot very quickly.

I still need to work out exactly constitutes “a short period”. If I start the engine cold and turn the throttle screw in to bring it off idle to a steady 2000rpm, the ignition retard defined by this table seems to take effect around 7-8 seconds after starting and persist for a little over 2 minutes. If on the other hand I try to maintain the revs by hand on the throttle quadrant and end up revving it a bit more, the effect seems to terminate after around 1 minute 40 seconds. So it may be defined in terms of a count of engine revolutions rather than a fixed time.

There is also some complex interplay between the main ignition timing table, this table and the table which I have provisionally name “Overrun Pop & Crackle Effects”. This is clearly not an appropriate final name for this mysterious table, but until I have managed to fully understand I’ve just named it after the effect it seems to be most affecting. It appears that making the changes I suggested to the Overrun Pop & Crackle Effects table also largely disables this ignition retard effect, so that table seems to be controlling the transition between the starting settings and normal running setting in some way.

Hint: On our cars you can turn this effect off by clearing the whole table to 0. Until I fully understand the Overrun Pop & Crackle Effects table, this is probably advisable to ensure that the changes made in that table don’t cause this effect to be applied inappropriately.

NB: This table is marked with “®” for “Research” as I still need to fully understand it.

revilla · April 18, 2020

Done some more digging today ...

I'm struggling a bit to find the effects of further tables without being able to take the car out on the road. One strategy that occurred to me was this: Try to find the minimum set of tables needed for the car, when warm (as it's not easy to do long term tests with it cold as it has a habit of warming up, at least the hot condition is stable) to start normally, idle normally, have apparently normal throttle response and a normal return to idle afterwards. In other words, how many tables can I clear out and still have a car that feels quite normal in the garage. The should leave me with the tables which control the really basic functions. I'm not saying the other tables do nothing. Some of them probably do indeed do nothing on our cars as they may be for air conditioning, charcoal canister control etc. Others will probably have significant effects under different temperature and load conditions, but if I could separate out the basics then when I do get the car on the road again I can identify the defects (especially if I instrument it to the eyeballs) and that will give me some things to go after.

The results were quite surprising...

Apart from the table I had already scribed functions to, I could clear out every other 3D table with no apparent effect other than it being a bit stumbly at idle immediately after starting, but this "wears off" after maybe 3 or 4 seconds, so it looks like I have inadvertently taken out some "post start" fuelling or ignition settings without noticing along the way; I can go back for those when I get the time.

That's a total of 55 of the total 80 3D tables that have little or no effect under low load conditions, and of the remaining 25 I already know what 16 of them do, so making some progress decoding it all.

The only single exception to the above was this table:

If I cleared this table to zero the idle became unstable, hunting up and down over a period of a few seconds. Once I saw this, the function of this table became reasonably obvious; it is the short term idle control through ignition timing. A few experiments flashing different different maps pretty much proved that it's as simple as the ignition timing under idle strategy as a function of the difference or error between the actual idle speed and the desired idle speed. So when the idle speed falls too low it advances the ignition to increase power and raise the idle speed, when the idle speed rises too high it retards. The other axis appears to be MAP; it surprised me a bit that idle control settings are mapped right up to 90kPa but there's very little resolution at the higher MAPs and the effect tails off towards a flatter ignition timing, so maybe this is just to give it some settings to use under transient unusual conditions (brake servo operation maybe?).

Anyway once I knew I had the short term idle stabilisation I went hunting for the long term idle control. I left the short term table blank and confirmed the idle was indeed hunting up and and down as it tried to chase it with the IACV alone (which too slow to respond for stable short term control).

I found this table with a very similar "error" axis scaling, symmetric positive and negative error values up to a few hundred:

It immediately looked like a sensible candidate; a small error band around zero with no response within which it would rely on the short term trim through ignition timing, with corrections either side, and a more aggressive response to lower than desirable idle speed to prevent stalls. I was a bit surprised that the Z axis values were positive either side of the zero band, but the ECU must apply the sign of the actual error (it is possible that this correction factor is a multiplier, which is multiplied by the actual error or something similar, in which case the sign would be correct).

I zeroed out this table and the idle again because stable. I suspect the idle will drift away from the normal value with temperature changes etc. now as the engine is making no attempt to correct it using either ignition timing or IACV inputs. I also tried doing things like programming a more aggressive response on one side of the curve and nothing on the other the results are as expected:

If I double the response to low idle RPMs and put zero response for high idle RPMs, the engine starts and runs normally, but the first time the RPM dips the IACV overreacts kicking the idle speed too high, then it just sits there with no desire to come back down again.
If I double the response to high idle RPMs and put zero response for low idle RPMs, the engine starts and runs normally but the first time the RPM rises a bit too high, the IACV again overreacts kicking the speed too low and the ECU fails to do anything about it, just letting the engine stall.

A longer term project is still to work out exactly what the Z axis represents on this table. It will be something like "rate of change of IACV position", but exactly how it is defined may take some working out. The consistent positive sign gives me a clue that it may be multiplied by the error value.

For now though that's one more feature tracked down to the point where it usable, one the basis of "a little bit more" or "a little bit less" if a modified engine has idle stabilisation issues.

At least every time I track down another table, even if it's not that useful it's one less to work out when looking for things that are more useful.

CharlesElliott · April 18, 2020

revilla · April 20, 2020

OK so I've decided to go hardcore ...

If I'm really going to understand this thing I'm going to have to get to grips with disassembling the actual firmware code of the ECU. There's a lot to learn. I've done quite a lot of Z80 assembly language programming (many years ago) and some x86 assembly language programming (only when absolutely necessary) but now I've got to learn Motorola 68000 assembly (the ECU is based around an MC68336 microcontroller which is an 68000-family CPU32 core plus peripherals).

I've got myself up and running with a decent disassembler which seems to do the job, and I've started picking it apart. Definitely seems like the kind of thing that's hard at the start and gets easier as you go along. So far I've worked out how to get right CPU type set up, how to get the code and data address ranges sorted out. I've also managed to work out how the vector tables work and from there where the entry points into the boot loader and firmware code are, which has given me a key in.

I don't need to to decode it all, but my thinking was if I can find the code that does the lookups into the tables, I can then find the routines that are handling the individual specific tables; and then I can see what other tables those same routines access and get a clue as to which tables relate to which others; and when I get a bit more confident, hopefully the calculations performed between them.

Already making some progress:

This is the main table access routine, which looks to be called by code all over to read values from both 2D and 3D table. The comments in blue are my start at deciphering exactly what the routine is doing. Already learned a few things from the code:

Where I have identified tables by index, the ECU internally identifies them by the address of their offset pointer in the index table. This is loaded into a register before calling this subroutine. It comes down to the same thing, my "Table N" is the ECUs "Table at $13C000 + Table Index Offset + 2*N". I'm guessing the high level tool used to program the thing did have a list of tables but they were compiled down to addresses by the compiler.
My earlier comment that 2D tables always seemed to have an X axis but Y axis and never the other way around seems to be a hard and fast rule as there is no check on the length of the X axis, only the Y axis (other than an error if 0 or less, as a 2D table still has a single value on the Y axis but no value associated with it).
The mysterious overlapped "Table 0" is not a mistake; there are separate table access routines which are hard-coded to read this particular table (it isn't read with the routine above like all other tables). No idea what they are doing with it yet though!

I've found where this routine is being used to calculate two tables which I already know are related in closely related code.

A long way still to go with this. Fun though!

revilla · April 22, 2020

Well I managed to find the time to decipher the table lookup subroutine instruction by instruction. The listing below is the raw disassembly plus my comments. Unfortunately the content management system has made a bit of a bit of a mess of listing it here!

The upshot of it all is:

There's just one single subroutine that does the lookups into both 2D and 3D tables.
The calculation ends up being pretty much what you would expect in each case.
Contrary to what I originally thought I saw in some of my earlier testing results, there is no linear extrapolation of values beyond the edges of the tables; any value beyond a table edge just uses the edge value. Values between axis values use linear interpolation.
The routine is called with the address of the map in register a5, the offset to the table index entry in register d1 and the axis values to be looked up in registers d2 (Y) and d3 (Y, if it's a 3D table).
The routine returns with the looked up, interpolated value in register d1 low word. Register d0 holds 0 if it succeeded or $ff to indicate an error; the only errors that it seems to detect are tables with zero length axes which should never exist as far as I can see, ad indeed all the places I've seen that call the routine so far don't check for an error code on return.

It's interesting just how much can be achieved with a single 68000/CPU32 machine instruction, it has some fairly complex instructions and addressing modes.

It had me stumped half way through. Once it has worked out the address of lower left hand cell that it needs to interpolate within, it goes ahead and calculates the addresses of the other corners and looks up the values; at this point I could see that it had already checked whether it was beyond the end of the x-axis but I couldn't see why it was safe to assume that the calculation wouldn't run past the end of the y-axis and overflow the table memory. In the end I decided to ignore that and come back to it and the answer became clear further down. I was right, it can overflow past the table memory giving gibberish results, but it does the check afterwards and discards the gibberish it calculated previously at that point. I've marked thee points with "NB: This may overflow end of table. If so calculates invalid data here and discards later!" in the comments.

So now I understand exactly how the ECU goes about looking up values from tables I can forget about the internals of this function and start to look at the code doing the lookups (by calling this function) to see what I can learn about how it links the tables and uses the values. Still not sure how much sense I will be able to make of anything but worth pursuing while I'm still making progress.

ROM:00115D2C ; =============== S U B R O U T I N E =======================================

ROM:00115D2C

ROM:00115D2C ; Used to look up values in both 2D and 3D tables.

ROM:00115D2C ;

ROM:00115D2C ; On entry:

ROM:00115D2C ;

ROM:00115D2C ; Register a5 points to the map = $13c000

ROM:00115D2C ; Register d1 low word holds the offset in the map to the table index entry.

ROM:00115D2C ; Register d2 low word holds the x axis lookup value.

ROM:00115D2C ; Register d3 low word holds the y axis lookup value (for a 3D table).

ROM:00115D2C ;

ROM:00115D2C ; On exit:

ROM:00115D2C ;

ROM:00115D2C ; Register d1 low word holds the looked up or interpolated value.

ROM:00115D2C ; Register d1 low byte holds $00 on success, or $ff on error.

ROM:00115D2C ; Error conditions: Either axis has less than 1 value.

ROM:00115D2C

ROM:00115D2C func_table_lookup: ; CODE XREF: sub_110706+26↑p

ROM:00115D2C ; sub_110706+46↑p ...

ROM:00115D2C movea.w (a5,d1.w),a0 ; a0 -> map offset to table data

ROM:00115D30 adda.l a5,a0 ; a0 -> address of table data (x_count)

ROM:00115D32 move.w (a0)+,d4 ; d4 -> x_count

ROM:00115D32 ; a0 -> address of y_count

ROM:00115D34 ble.w return_error ; return error code if x_count < 1

ROM:00115D38 move.w (a0)+,d5 ; d5 -> y_count

ROM:00115D38 ; a0 - > address of x_first

ROM:00115D3A ble.w return_error ; return error code if y_count < 1

ROM:00115D3E move.w d4,d7 ; d7 -> x_count

ROM:00115D40 subq.w #1,d7 ; d7 -> x_count - 1

ROM:00115D42 adda.w d4,a0

ROM:00115D44 adda.w d4,a0 ; a0 -> address of y_first (3d) or z_first (2d)

ROM:00115D46 movea.l a0,a1 ; a1 -> address of y_first (3d) or z_first (2d)

ROM:00115D48

ROM:00115D48 next_x_value: ; CODE XREF: func_table_lookup+1E↓j

ROM:00115D48 cmp.w -(a1),d2 ; a1 -> address of x_values[d7]

ROM:00115D48 ; compare x_values[d7] with x_lookup

ROM:00115D4A dbge d7,next_x_value ; if x_lookup < x_values[d7] then

ROM:00115D4A ; dec d7

ROM:00115D4A ; if d7 >= 0 then branch next_x_value

ROM:00115D4E bge.s x_lower_found ; if an x axis value lower than x_lookup (x_lower) is found then branch x_lower_found

ROM:00115D50 clr.w d7 ; d7 -> 0

ROM:00115D52 bra.s no_x_lower ; branch no_x_lower

ROM:00115D54 ; ---------------------------------------------------------------------------

ROM:00115D54

ROM:00115D54 x_lower_found: ; CODE XREF: func_table_lookup+22↑j

ROM:00115D54 move.w (a1)+,d0 ; d0 low word -> x_lower

ROM:00115D54 ; a1 -> address of x_lower + 2

ROM:00115D56 cmpa.l a1,a0

ROM:00115D58 bne.s get_x_upper ; if x_lower is not the last x value then branch get_x_upper

ROM:00115D5A subq.l #2,a1 ; a1 -> address of last x axis value

ROM:00115D5C

ROM:00115D5C no_x_lower: ; CODE XREF: func_table_lookup+26↑j

ROM:00115D5C move.w (a1),d0 ; d0 low word -> x_lower (or x_first if no x_lower found)

ROM:00115D5E

ROM:00115D5E get_x_upper: ; CODE XREF: func_table_lookup+2C↑j

ROM:00115D5E swap d0 ; x_lower moves to d0 high word

ROM:00115D60 move.w (a1),d0 ; d0 - > x_lower | x_upper

ROM:00115D62 swap d0 ; d0 -> x_upper | x_lower

ROM:00115D64 move.w d5,d1 ; d1 -> y_count

ROM:00115D66 subq.w #1,d1 ; d1-> y_count - 1

ROM:00115D68 beq.w table_is_2d ; if y axis count - 1 = 0 then branch table_is_2d

ROM:00115D6C adda.w d5,a0

ROM:00115D6E adda.w d5,a0 ; a0 -> address of z_first

ROM:00115D70 movea.l a0,a1 ; a1 -> address of z_first

ROM:00115D72 swap d2 ; x_lookup moves to 2 high word

ROM:00115D74

ROM:00115D74 next_y_value: ; CODE XREF: func_table_lookup+4A↓j

ROM:00115D74 cmp.w -(a1),d3 ; a1 -> address of y_values[d1]

ROM:00115D74 ; compare y_values[d1] with y_lookup

ROM:00115D76 dbge d1,next_y_value ; if y_lookup < y_values[d1] then

ROM:00115D76 ; dec d1

ROM:00115D76 ; if d1 >= 0 then branch next_y_value

ROM:00115D7A bge.s y_lower_found ; if a y axis value lower than y_lookup (y_lower) is found then branch y_lower_found

ROM:00115D7C clr.w d1 ; d1 -> 0

ROM:00115D7E bra.s no_y_lower ; branch no_y_lower

ROM:00115D80 ; ---------------------------------------------------------------------------

ROM:00115D80

ROM:00115D80 y_lower_found: ; CODE XREF: func_table_lookup+4E↑j

ROM:00115D80 move.w (a1)+,d2 ; d2 low word -> y_lower

ROM:00115D80 ; a1 -> address of y_lower + 2

ROM:00115D82 cmpa.l a1,a0

ROM:00115D84 bne.s get_y_upper ; if y_lower is not the last y value then branch get_y_upper

ROM:00115D86 subq.l #2,a1 ; a1 -> address of last y axis value

ROM:00115D88

ROM:00115D88 no_y_lower: ; CODE XREF: func_table_lookup+52↑j

ROM:00115D88 move.w (a1),d2 ; d2 low word -> y_lower (or y_first if no y_lower found)

ROM:00115D8A

ROM:00115D8A get_y_upper: ; CODE XREF: func_table_lookup+58↑j

ROM:00115D8A swap d3 ; y_lookup moves to d3 high word

ROM:00115D8C move.w (a1),d3 ; d3 -> y_lookup | y_upper

ROM:00115D8E muls.w d4,d1

ROM:00115D90 muls.w #2,d1 ; d1 - > y_lower_idx * x_count * 2

ROM:00115D94 adda.l d1,a0 ; a0 - > address of z_values[0, y_lower_idx]

ROM:00115D96 adda.w d7,a0

ROM:00115D98 adda.w d7,a0 ; a0 - > address of data z_values[x_lower_idx, y_lower_idx]

ROM:00115D9A move.l d2,d6 ; d6 - > x_lookup | y_lower

ROM:00115D9C swap d6 ; d6 - > y_lower | x_lookup

ROM:00115D9E sub.w d0,d6 ; d6 low word -> x_lookup - x_lower

ROM:00115DA0 ble.s use_x_lower ; if x_lookup <= x_lower then branch use_x_lower

ROM:00115DA2 move.l d0,d5 ; d5 - > x_upper | x_lower

ROM:00115DA4 swap d5 ; d5 - > x_lower | x_upper

ROM:00115DA6 sub.w d0,d5 ; d5 low word -> x_upper - x_lower

ROM:00115DA8 beq.s use_x_lower ; if x_upper = x_lower then branch use_x_lower

ROM:00115DAA move.w 2(a0),d7 ; d7 low word -> z_values[x_lower_idx + 1, y_lower_idx]

ROM:00115DAE sub.w (a0),d7 ; d7 low word -> z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]

ROM:00115DB0 beq.s no_z_delta_lower ; if no z delta over x for y_lower_idx then branch no_z_delta_lower

ROM:00115DB2 muls.w d6,d7 ; d7 low word -> (z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]) * (x_lookup - x_lower)

ROM:00115DB4 divs.w d5,d7 ; d7 low word -> (z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DB6

ROM:00115DB6 no_z_delta_lower: ; CODE XREF: func_table_lookup+84↑j

ROM:00115DB6 add.w (a0),d7 ; d7 low word -> z_values[x_lower_idx, y_lower_idx] + (z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DB8 move.w 2(a0,d4.w*2),d1 ; d1 low word -> z_values[x_lower_idx + 1, y_lower_idx + 1]

ROM:00115DB8 ; NB: This may overflow end of table. If so calculates invalid data here and discards later!

ROM:00115DBC sub.w (a0,d4.w*2),d1 ; d1 low word -> z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]

ROM:00115DBC ; NB: This may overflow end of table. If so calculates invalid data here and discards later!

ROM:00115DC0 beq.s no_z_delta_upper ; if no z delta over x for y_lower_idx + 1 then branch no_z_delta_upper

ROM:00115DC2 muls.w d6,d1 ; d1 low word -> (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower)

ROM:00115DC4 divs.w d5,d1 ; d1 low word -> (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DC6

ROM:00115DC6 no_z_delta_upper: ; CODE XREF: func_table_lookup+94↑j

ROM:00115DC6 add.w (a0,d4.w*2),d1 ; d1 low word -> z_values[x_lower_idx, y_lower_idx + 1] + (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DCA bra.s interp_on_y

ROM:00115DCC ; ---------------------------------------------------------------------------

ROM:00115DCC

ROM:00115DCC use_x_lower: ; CODE XREF: func_table_lookup+74↑j

ROM:00115DCC ; func_table_lookup+7C↑j

ROM:00115DCC move.w (a0),d7 ; d7 low word -> z_values[x_lower_idx, y_lower_idx]

ROM:00115DCE move.w (a0,d4.w*2),d1 ; d1 low word -> z_values[x_lower_idx, y_lower_idx + 1]

ROM:00115DCE ; NB: This may overflow end of table. If so calculates invalid data here and discards later!

ROM:00115DD2

ROM:00115DD2 interp_on_y: ; CODE XREF: func_table_lookup+9E↑j

ROM:00115DD2 move.l d3,d6 ; d6 -> y_lookup | y_upper

ROM:00115DD4 swap d6 ; d6 -> y_upper | y_lookup

ROM:00115DD6 sub.w d2,d6 ; d6 low word -> y_lookup - y_lower

ROM:00115DD8 ble.s use_y_lower ; if y_lookup <= y_lower then branch use_y_lower

ROM:00115DDA move.w d3,d5 ; d5 low word -> y_upper

ROM:00115DDC sub.w d2,d5 ; d5 low word -> y_upper - y_lower

ROM:00115DDE beq.s use_y_lower ; if y_upper = y_lower then branch use_y_lower

ROM:00115DE0 sub.w d7,d1

ROM:00115DE2 beq.s use_y_lower ; if no z delta over y between interpolations over x then branch use_y_lower

ROM:00115DE4 muls.w d6,d1 ; d1 low word -> z_values[x_lower_idx, y_lower_idx + 1] + (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower) / (x_upper - x_lower) * (y_lookup - y_lower)

ROM:00115DE6 divs.w d5,d1 ; d1 low word -> z_values[x_lower_idx, y_lower_idx + 1] + (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower) / (x_upper - x_lower) * (y_lookup - y_lower) / (y_lookup - y_lower)

ROM:00115DE8 add.w d7,d1 ; d1 low word -> z_values[x_lower_idx, y_lower_idx + 1] + (z_values[x_lower_idx + 1, y_lower_idx + 1] - z_values[x_lower_idx, y_lower_idx + 1]) * (x_lookup - x_lower) / (x_upper - x_lower) * (y_lookup - y_lower) / (y_lookup - y_lower) + z_values[x_lower_idx, y_lower_idx] + (z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DEA bra.s return_ok

ROM:00115DEC ; ---------------------------------------------------------------------------

ROM:00115DEC

ROM:00115DEC use_y_lower: ; CODE XREF: func_table_lookup+AC↑j

ROM:00115DEC ; func_table_lookup+B2↑j ...

ROM:00115DEC move.w d7,d1 ; d1 -> z_values[x_lower_idx, y_lower_idx] + (z_values[x_lower_idx + 1, y_lower_idx] - z_values[x_lower_idx, y_lower_idx]) * (x_lookup - x_lower) / (x_upper - x_lower)

ROM:00115DEE bra.s return_ok

ROM:00115DF0 ; ---------------------------------------------------------------------------

ROM:00115DF0

ROM:00115DF0 table_is_2d: ; CODE XREF: func_table_lookup+3C↑j

ROM:00115DF0 adda.w d7,a0

ROM:00115DF2 adda.w d7,a0 ; a0 -> address of z_values[x_lower_idx]

ROM:00115DF4 move.w d2,d6 ; d6 low word -> x_lookup

ROM:00115DF6 sub.w d0,d6 ; d6 low word -> x_lookup - x_lower

ROM:00115DF8 ble.s use_x_lower_2d ; if x_lookup <= x_lower then branch use_x_lower_2d

ROM:00115DFA move.l d0,d5 ; d5 -> x_upper | x_lower

ROM:00115DFC swap d5 ; d5 -> x_lower | x_upper

ROM:00115DFE sub.w d0,d5 ; d5 low word -> x_upper - x_lower

ROM:00115E00 beq.s use_x_lower_2d ; if x_upper = x_lower then branch use_x_lower_2d

ROM:00115E02 move.w 2(a0),d1 ; d1 -> z_values[x_upper_idx]

ROM:00115E06 sub.w (a0),d1 ; d1 -> z_values[x_upper_idx] - z_values[x_lower_idx]

ROM:00115E08 beq.s use_x_lower_2d ; if no z delta over x then branch use_x_lower_2d

ROM:00115E0A muls.w d6,d1 ; d1 -> (z_values[x_upper_idx] - z_values[x_lower_idx]) * (x_lookup - x_Lower)

ROM:00115E0C divs.w d5,d1 ; d1 -> (z_values[x_upper_idx] - z_values[x_lower_idx]) * (x_lookup - x_Lower) / (x_upper - x_lower)

ROM:00115E0E add.w (a0),d1 ; d1 -> z_values[x_lower_idx] + (z_values[x_upper_idx] - z_values[x_lower_idx]) * (x_lookup - x_Lower) / (x_upper - x_lower)

ROM:00115E10 bra.s return_ok

ROM:00115E12 ; ---------------------------------------------------------------------------

ROM:00115E12

ROM:00115E12 use_x_lower_2d: ; CODE XREF: func_table_lookup+CC↑j

ROM:00115E12 ; func_table_lookup+D4↑j ...

ROM:00115E12 move.w (a0),d1

ROM:00115E14

ROM:00115E14 return_ok: ; CODE XREF: func_table_lookup+BE↑j

ROM:00115E14 ; func_table_lookup+C2↑j ...

ROM:00115E14 moveq #0,d0

ROM:00115E16 bra.s table_lookup_return

ROM:00115E18 ; ---------------------------------------------------------------------------

ROM:00115E18

ROM:00115E18 return_error: ; CODE XREF: func_table_lookup+8↑j

ROM:00115E18 ; func_table_lookup+E↑j

ROM:00115E18 move.b #$FF,d0

ROM:00115E1C

ROM:00115E1C table_lookup_return: ; CODE XREF: func_table_lookup+EA↑j

ROM:00115E1C rts

ROM:00115E1C ; End of function func_table_lookup

ROM:00115E1C

ECR · April 22, 2020

Andrew, if I understood a tenth of what you're reporting I'd be happy. Despite that I find it fascinating to see how you unpick things, it's addictive.....

Carry on!

revilla · April 22, 2020

Next steps ...

I started looking for where particular tables were used, with some success, but I hit the same problem every time:

So for example here's the subroutine that looks up the ignition timing:

ROM:00120EDA
ROM:00120EDA ; =============== S U B R O U T I N E =======================================
ROM:00120EDA
ROM:00120EDA ; Called to look up values from the Igniton Timing table and update the var_igntion_timing_base and var_igntion_timing_adjusted variables.
ROM:00120EDA ;
ROM:00120EDA func_lookup_ignition_timing: ; CODE XREF: ROM:loc_120D9E↑p
ROM:00120EDA ; ROM:loc_120E26↑p ...
ROM:00120EDA move.w #$3C3A,d1
ROM:00120EDE move.w (var_map).w,d2
ROM:00120EE2 move.w (var_rpm).w,d3
ROM:00120EE6 bsr.l func_table_lookup
ROM:00120EEC move.w d1,(var_ignition_timing_base).w
ROM:00120EF0 move.w $42C(a5),d0
ROM:00120EF4 cmp.w (var_map).w,d0
ROM:00120EF8 bgt.s loc_120F02
ROM:00120EFA bset #2,(var_flags_1).w
ROM:00120F00 bra.s loc_120F12
ROM:00120F02 ; ---------------------------------------------------------------------------
ROM:00120F02
ROM:00120F02 loc_120F02: ; CODE XREF: func_lookup_ignition_timing+1E↑j
ROM:00120F02 sub.w $42A(a5),d0
ROM:00120F06 cmp.w (var_map).w,d0
ROM:00120F0A ble.s loc_120F12
ROM:00120F0C bclr #2,(var_flags_1).w
ROM:00120F12
ROM:00120F12 loc_120F12: ; CODE XREF: func_lookup_ignition_timing+26↑j
ROM:00120F12 ; func_lookup_ignition_timing+30↑j
ROM:00120F12 btst #2,(var_flags_1).w
ROM:00120F18 beq.s loc_120F1E
ROM:00120F1A add.w (var_ignition_timing_adjustment).w,d1
ROM:00120F1E
ROM:00120F1E loc_120F1E: ; CODE XREF: func_lookup_ignition_timing+3E↑j
ROM:00120F1E move.w d1,(var_ignition_timing_adjusted).w
ROM:00120F22 rts
ROM:00120F22 ; End of function func_lookup_ignition_timing
ROM:00120F22
ROM:00120F24

There are quite few things to be learned from that:

There's a table lookup bsr.l func_table_lookup and we now know how that works, and that d2 and d3 are the X and Y axes which for that particular table are MAP and RPM; it's fetching d2 and d3 from global variables in RAM so we can guess they are used to hold the current calculated MAP and RPM and name them accordingly.
It's reading a couple of scalar values in lines such as move.w $42C(a5),d0 - register a5 holds the address of the map $13C000 so that is reading the scalar at $13C42C.
The overall logic is applying a sort of hysteresis; as well as looking up the ignition timing, when the MAP goes above 50kPa it's setting a flag and when it falls below 45kPa it's clearing it.
When the flag is set it applies an adjustment from another RAM variable to the ignition timing; this will probably be calculated from trims elsewhere.

I've written out the logic in pseudocode here:

var_ignition_timing_base := func_table_lookup(Table "Ignition Timing", var_map, var_rpm)

if var_map >= Scalar "Ign. Timing Adjustment MAP Thresh." (e.g. 50kPa) then
set var_flags_1 bit 2
else
if var_map < Scalar "Ign. Timing Adjustment MAP Thresh." - Scalar "Ign. Timing Adjustment MAP Hyst." (e.g. 5kPa) then
clear var_flags_1 bit 2

if var_flags_1 bit 2 then
var_ignition_timing_adjusted := var_igntion_timing_base + var_ignition_timing_adjustment
else
var_ignition_timing_adjusted := var_igntion_timing_base

The problem comes when I come to look where and how the trim adjustment is calculated.

The disassembler will give me a tree of references to that variable:

It's referenced by the subroutine we know about and one other; but both of those are called by code in the ROM which doesn't seem to be part of an identifiable subroutine.

These references are all either in non-executable data, or in snippets of code as can be seen below:

These look odd because there are no links into these bits of code; nothing ever seems to be able to call them. So they are dead ends.

After rummaging around a bit I realised what was going on.

The machine code in the ECU was generated by a compiler from some higher-level language (possibly C?). Although direct calls to functions and procedures were compiled as hard coded calls in the assembly language, some things were not. Things like switch/case statements where some sort of value is calculated and the code branches to different places depending upon the value. In these cases, the address to jump to is calculated by logic in the main subroutine in an address register such as a0, and then it jumps to that as a subroutine call with an instruction such as jsr (ao) - but there's no way the disassembler can know where this will jump to at run time so there are no apparent links shown.

Interestingly you can see the telltale signs of the compilation from a higher level language all over if you look:

Something like ...

if ConditionA then
DoB
else
DoC;

... always seems to end up implemented as ...

test ConditionA
branch if true to label_true
DoC
branch to label_endif
label_true:
DoB:
label_endif

... which is quite a recognisable and precisely repeated pattern.

Similarly the case statements always seem to end up something like ...

begin subroutine
calculate case_address
jump to subroutine case_address
end subroutine
label_case1:
Do thing 1.
return from subroutine
label_case:
Do thing 2.
return from subroutine

... it always returns to the main subroutine from the case parts even when there is nothing further to do. If coding in assembly by hand, you probably wouldn't bother. It's just the original structure of the high level source code showing through.

And the bits in bold above are the apparently disconnected subroutines, which are actually effectively part of the main subroutine but they come after then end of the main subroutine with apparently no links into them.

Unfortunately as it stands, this makes following the links between parts of the code nigh on impossible.

However, as it was compiled from a high level language, we can be sure that the structure will be fairly rigid and we can get a lot of clues. The disconnected fragments always appear to come immediately after the main body of the subroutine etc. So we can use these clues to infer what code actually belongs to what.

So my next job:

I need to write a piece of software that will take a text-file dump of the whole disassembled listing and parse it up into subroutines, effectively reconstituting the detached pieces so they become part of the original subroutine. Then it needs to build a complete network of all the subroutines and the links between them, listing the tables, scalars and RAM variables referenced by each, then it needs to present this all graphically so I can use it for reference when walking the code alongside the disassembler.

I may be a little while ...

revilla · April 22, 2020

Got as far as parsing the disassembly and building up a list of all of the subroutines, the complete re-connected text of each one and the lists of other subroutines, tables and scalars each one references. Tomorrow's job is to turn it into something graphical and usable. Would be useful if for any subroutine I could display a tree of all the things it uses (recursively) or all the things that use it.

I need to add RAM addresses to the list of what it traces too, then I can find the code that updates specific variables.

Subroutine sub_10041C Refers to Subroutines: sub_100628 sub_100708 sub_100740 sub_1007A2 sub_1007CA sub_1007F8
Subroutine sub_10041C Refers to Scalars: $13C03C
Subroutine sub_1007CA Refers to Subroutines: sub_1007F8
Subroutine sub_1007EC Refers to Subroutines: sub_100B76
Subroutine sub_1007F8 Refers to Subroutines: sub_1007CA sub_10292A sub_10370E sub_1058A4 sub_105DBE
Subroutine sub_100874 Refers to Subroutines: sub_1008FC sub_100966
Subroutine sub_1008A4 Refers to Subroutines: sub_1008FC
Subroutine sub_1008FC Refers to Subroutines: sub_100874 sub_1008A4
Subroutine sub_100966 Refers to Subroutines: sub_100874 sub_100A1C sub_100B08
Subroutine sub_100982 Refers to Subroutines: sub_1008A4 sub_100B08 sub_100B76
Subroutine sub_1009BC Refers to Subroutines: sub_100982 sub_100A1C
Subroutine sub_100A1C Refers to Subroutines: sub_100966 sub_1009BC sub_100B08 sub_100B76
Subroutine sub_100B08 Refers to Subroutines: sub_100966 sub_100982 sub_100A1C sub_100BB8 sub_100BF4
Subroutine sub_100B76 Refers to Subroutines: sub_1007EC sub_100966 sub_100982 sub_100A1C
Subroutine sub_100BB8 Refers to Subroutines: sub_100982 sub_100B08
Subroutine sub_100BF4 Refers to Subroutines: sub_1008FC sub_100A1C sub_100B08
Subroutine sub_100CFC Refers to Subroutines: sub_101430 sub_101446 sub_101458 sub_10146A sub_10147C sub_1014AE sub_10170A sub_1027A8
Subroutine sub_101430 Refers to Subroutines: sub_100CFC sub_101646
Subroutine sub_101446 Refers to Subroutines: sub_100CFC sub_101646
Subroutine sub_101458 Refers to Subroutines: sub_100CFC sub_101646
Subroutine sub_10146A Refers to Subroutines: sub_100CFC sub_101646
Subroutine sub_10147C Refers to Subroutines: sub_100CFC sub_101646
Subroutine sub_1014AE Refers to Subroutines: sub_100CFC sub_1014BC
Subroutine sub_1014BC Refers to Subroutines: sub_1014AE sub_1015AA sub_1016AC
Subroutine sub_1015AA Refers to Subroutines: sub_1014BC
Subroutine sub_101622 Refers to Subroutines: sub_101646 sub_101F40 sub_101F9C
Subroutine sub_101646 Refers to Subroutines: sub_101430 sub_101446
Subroutine sub_1016AC Refers to Subroutines: sub_1014BC sub_101730
Subroutine sub_10170A Refers to Subroutines: sub_100CFC sub_101730 sub_101D72
Subroutine sub_101730 Refers to Subroutines: sub_1016AC sub_10170A sub_101F40 sub_101F9C sub_101FEC sub_102006 sub_10201A sub_102022 sub_10204A sub_1020A6 sub_1020B6 sub_1020E0 sub_10216A sub_10217A sub_1021E6 sub_102252 sub_102268 sub_102274 sub_1022C0 sub_1022D4 sub_10231E sub_102338 sub_102366 sub_10240C sub_102496 sub_10250A sub_102582 sub_1025B0 sub_1025BC sub_1025D0 sub_102650 sub_102748 sub_1036EC
Subroutine sub_101D72 Refers to Subroutines: sub_10170A sub_101F40 sub_101F9C sub_101FEC sub_102006 sub_10216A sub_102252 sub_102268 sub_10231E
Subroutine sub_101F40 Refers to Subroutines: sub_101622 sub_101730 sub_101D72
Subroutine sub_101F9C Refers to Subroutines: sub_101622 sub_101730 sub_101D72
Subroutine sub_101FEC Refers to Subroutines: sub_101646 sub_101730 sub_101D72
Subroutine sub_102006 Refers to Subroutines: sub_101646 sub_101730 sub_101D72
Subroutine sub_10201A Refers to Subroutines: sub_101730
Subroutine sub_102022 Refers to Subroutines: sub_101730
Subroutine sub_10204A Refers to Subroutines: sub_101730
Subroutine sub_1020A6 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_1020B6 Refers to Subroutines: sub_101622 sub_101730
Subroutine sub_1020E0 Refers to Subroutines: sub_101730
Subroutine sub_10216A Refers to Subroutines: sub_101646 sub_101730 sub_101D72
Subroutine sub_10217A Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_1021E6 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_102252 Refers to Subroutines: sub_101646 sub_101730 sub_101D72
Subroutine sub_102268 Refers to Subroutines: sub_101730 sub_101D72
Subroutine sub_102274 Refers to Subroutines: sub_101730
Subroutine sub_1022C0 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_1022D4 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_10231E Refers to Subroutines: sub_101646 sub_101730 sub_101D72
Subroutine sub_102338 Refers to Subroutines: sub_101730
Subroutine sub_102366 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_10240C Refers to Subroutines: sub_101730
Subroutine sub_102496 Refers to Subroutines: sub_101622 sub_101730
Subroutine sub_10250A Refers to Subroutines: sub_101622 sub_101730
Subroutine sub_102582 Refers to Subroutines: sub_101730
Subroutine sub_1025B0 Refers to Subroutines: sub_101730
Subroutine sub_1025BC Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_1025D0 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_102650 Refers to Subroutines: sub_101646 sub_101730
Subroutine sub_102748 Refers to Subroutines: sub_101646 sub_1016AC sub_101730
Subroutine sub_1027A8 Refers to Subroutines: sub_100CFC sub_102828 sub_10283A sub_102850
Subroutine sub_102828 Refers to Subroutines: sub_101646 sub_1027A8
Subroutine sub_10283A Refers to Subroutines: sub_101646 sub_1027A8
Subroutine sub_102850 Refers to Subroutines: sub_101646 sub_1027A8 sub_102B86 sub_102F22 sub_103348 sub_103388
Subroutine sub_102924 Refers to Subroutines: sub_102C72
Subroutine sub_10292A Refers to Subroutines: sub_1007F8 sub_102938 sub_1030AC sub_105F3E
Subroutine sub_102938 Refers to Subroutines: sub_1014AE sub_10292A sub_10341A sub_10349C sub_1034C0 sub_1034D2 sub_1034E4 sub_1034F6 sub_105F98 sub_105FAA
Subroutine sub_102938 Refers to Scalars: $13C026 $13C028 $13C026 $13C028
Subroutine sub_102B86 Refers to Subroutines: sub_103504 sub_1035C0 sub_108C46 sub_10910C
Subroutine sub_102C72 Refers to Subroutines: sub_102924 sub_103504 sub_103556 sub_103564 sub_10358E
Subroutine sub_102C72 Refers to Scalars: $13C024 $13C034
Subroutine sub_102F22 Refers to Subroutines: sub_1034C0 sub_1034D2 sub_103504 sub_103532 sub_10358E
Subroutine sub_102F22 Refers to Scalars: $13C030 $13C032
Subroutine sub_1030AC Refers to Subroutines: sub_10292A sub_103504 sub_10356A sub_103572 sub_10357A sub_103582
Subroutine sub_1030AC Refers to Scalars: $13C018 $13C01A $13C01A $13C01C $13C020 $13C01E $13C026 $13C028
Subroutine sub_10343C Refers to Subroutines: sub_105F3E
Subroutine sub_10343C Refers to Scalars: $13C036
Subroutine sub_1034C0 Refers to Scalars: $13C014
Subroutine sub_1034D2 Refers to Scalars: $13C014
Subroutine sub_103504 Refers to Subroutines: sub_102B86
Subroutine sub_103532 Refers to Subroutines: sub_102F22
Subroutine sub_103532 Refers to Scalars: $13C02E $13C02A $13C02C $13C02C
Subroutine sub_1035C0 Refers to Subroutines: sub_102B86 sub_1036EC
Subroutine sub_1036EC Refers to Subroutines: sub_101730
Subroutine sub_10370E Refers to Subroutines: sub_1007F8 sub_10371E sub_1038F6
Subroutine sub_10371E Refers to Subroutines: sub_10370E sub_103F92 sub_103FAC sub_104018 sub_104042 sub_10409E sub_104150 sub_1041CA sub_10420E sub_1042CC sub_1042FA sub_10436C sub_10438E sub_1043C2
Subroutine sub_1038F6 Refers to Subroutines: sub_10370E sub_103F92 sub_103FAC sub_104018 sub_10409E sub_1040C0 sub_1040F4 sub_104124 sub_104138 sub_104266 sub_10429C sub_1042DE sub_104330 sub_104342 sub_104350 sub_10435E sub_1043F0 sub_104408 sub_10441A sub_104428 sub_104442
Subroutine sub_1038F6 Refers to Scalars: $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A $13C00A
Subroutine sub_103F46 Refers to Subroutines: sub_104150
Subroutine sub_104056 Refers to Subroutines: sub_1040C0 sub_104124
Subroutine sub_1040C0 Refers to Subroutines: sub_104056
Subroutine sub_104124 Refers to Subroutines: sub_104056
Subroutine sub_104138 Refers to Subroutines: sub_104056
Subroutine sub_104150 Refers to Subroutines: sub_103F46
Subroutine sub_1041CA Refers to Subroutines: sub_103F46
Subroutine sub_10420E Refers to Subroutines: sub_103F46
Subroutine sub_104266 Refers to Subroutines: sub_104056
Subroutine sub_1042CC Refers to Subroutines: sub_103F46
Subroutine sub_1042DE Refers to Subroutines: sub_104056
Subroutine sub_1042FA Refers to Subroutines: sub_103F46
Subroutine sub_104330 Refers to Subroutines: sub_104056
Subroutine sub_10436C Refers to Subroutines: sub_103F46
Subroutine sub_10438E Refers to Subroutines: sub_103F46
Subroutine sub_1043C2 Refers to Subroutines: sub_103F46
Subroutine sub_1043F0 Refers to Subroutines: sub_104056
Subroutine sub_104408 Refers to Subroutines: sub_104056
Subroutine sub_10441A Refers to Subroutines: sub_104056
Subroutine sub_104428 Refers to Subroutines: sub_104056
Subroutine sub_104442 Refers to Subroutines: sub_104056
Subroutine sub_104450 Refers to Subroutines: sub_1046A8
Subroutine sub_1045E2 Refers to Subroutines: sub_10466C sub_1046A8
Subroutine sub_10466C Refers to Subroutines: sub_1045E2
Subroutine sub_1046A8 Refers to Subroutines: sub_104450 sub_1045E2
Subroutine sub_1046C6 Refers to Subroutines: sub_10473E sub_10482E
Subroutine sub_10473E Refers to Subroutines: sub_1046C6 sub_1063C2
Subroutine sub_104792 Refers to Subroutines: sub_10482E
Subroutine sub_10482E Refers to Subroutines: sub_1046C6 sub_1063C2
Subroutine sub_1048BE Refers to Subroutines: sub_1048EE sub_105C34
Subroutine sub_1048D6 Refers to Subroutines: sub_10494C sub_105C34
Subroutine sub_1048EE Refers to Subroutines: sub_1048BE sub_1049AA
Subroutine sub_10494C Refers to Subroutines: sub_1048D6 sub_1049AA
Subroutine sub_1049AA Refers to Subroutines: sub_104884 sub_1048EE sub_10494C
Subroutine sub_104A08 Refers to Subroutines: sub_104B28 sub_104BFE sub_104CD4 sub_104D0A sub_104DAC sub_104DEE sub_104E28 sub_104E82 sub_104F66 sub_104FDA sub_107722
Subroutine sub_105004 Refers to Subroutines: sub_1050CE sub_105114 sub_10518C sub_1051C2 sub_1052EC sub_105342 sub_1063C2 sub_107088
Subroutine sub_105114 Refers to Subroutines: sub_1053D4
Subroutine sub_10518C Refers to Subroutines: sub_1053D4
Subroutine sub_1052EC Refers to Subroutines: sub_1053D4
Subroutine sub_1053D4 Refers to Subroutines: sub_105114 sub_10518C sub_1055EA sub_105634 sub_1056CA sub_105766 sub_105792 sub_1057B4 sub_1057E2 sub_1057FC
Subroutine sub_105634 Refers to Subroutines: sub_109654
Subroutine sub_1058A4 Refers to Subroutines: sub_1007F8 sub_1059A2 sub_1059B4
Subroutine sub_105926 Refers to Subroutines: sub_107722
Subroutine sub_105954 Refers to Subroutines: sub_107722
Subroutine sub_1059A2 Refers to Subroutines: sub_1059B4
Subroutine sub_1059B4 Refers to Subroutines: sub_1059A2 sub_105A5A sub_105A96 sub_105C34
Subroutine sub_105B46 Refers to Subroutines: sub_105C34
Subroutine sub_105C34 Refers to Subroutines: sub_1048BE sub_1048D6
Subroutine sub_105C56 Refers to Subroutines: sub_105CCE sub_105D68
Subroutine sub_105CCE Refers to Subroutines: sub_105C56 sub_105D68 sub_1063C2
Subroutine sub_105D68 Refers to Subroutines: sub_105C56 sub_1063C2
Subroutine sub_105DBE Refers to Subroutines: sub_1007F8 sub_102924 sub_105E66 sub_105EF0
Subroutine sub_105E66 Refers to Subroutines: sub_105EF0
Subroutine sub_105F3E Refers to Subroutines: sub_10292A sub_10343C
Subroutine sub_105F98 Refers to Subroutines: sub_105FE2 sub_107A22 sub_107E48
Subroutine sub_105FAA Refers to Subroutines: sub_107A22 sub_107E48 sub_108C46 sub_10910C
Subroutine sub_105FE2 Refers to Subroutines: sub_105F98
Subroutine sub_1063C2 Refers to Subroutines: sub_10473E sub_10482E sub_105004 sub_105CCE sub_105D68 sub_106FA4 sub_106FF8 sub_107088 sub_1070EC sub_107228 sub_10745C sub_1074C0 sub_107540 sub_109654
Subroutine sub_106FA4 Refers to Subroutines: sub_1063C2 sub_10745C sub_1074C0
Subroutine sub_106FF8 Refers to Subroutines: sub_1063C2 sub_10745C
Subroutine sub_107088 Refers to Subroutines: sub_1063C2 sub_10745C
Subroutine sub_1070EC Refers to Subroutines: sub_1063C2 sub_10745C
Subroutine sub_107228 Refers to Subroutines: sub_1063C2
Subroutine sub_10745C Refers to Subroutines: sub_1063C2
Subroutine sub_1074C0 Refers to Subroutines: sub_1063C2 sub_106FA4 sub_106FF8 sub_109654
Subroutine sub_107540 Refers to Subroutines: sub_104792 sub_1063C2 sub_106FF8 sub_10745C
Subroutine sub_107722 Refers to Subroutines: sub_104A08 sub_105926 sub_105954 sub_107AFA
Subroutine sub_107A22 Refers to Subroutines: sub_105F98 sub_105FAA
Subroutine sub_107A22 Refers to Scalars: $13C038 $13C038
Subroutine sub_107AFA Refers to Subroutines: sub_107722 sub_107C04 sub_107C34 sub_107C4E sub_109654
Subroutine sub_107C04 Refers to Subroutines: sub_107AFA
Subroutine sub_107C34 Refers to Subroutines: sub_107AFA
Subroutine sub_107C4E Refers to Subroutines: sub_107AFA
Subroutine sub_107E48 Refers to Subroutines: sub_105F98 sub_105FAA sub_10852E sub_109038 sub_10907E
Subroutine sub_107E48 Refers to Scalars: $13C03A
Subroutine sub_1081A2 Refers to Scalars: $13C026 $13C040 $13C041
Subroutine sub_10852E Refers to Subroutines: sub_1061FA sub_1063C2 sub_107722 sub_109038 sub_10907E sub_1091A0
Subroutine sub_10852E Refers to Scalars: $13C03C $13C03C $13C03C $13C03C $13C03C $13C03C
Subroutine sub_108C46 Refers to Subroutines: sub_102B86 sub_105FAA sub_108C5A sub_108E0E
Subroutine sub_108C5A Refers to Subroutines: sub_108C46 sub_1090B8 sub_1090C2 sub_1090FC
Subroutine sub_108C5A Refers to Scalars: $13C03E $13C03E $13C03E $13C03E $13C03E $13C03E
Subroutine sub_108E0E Refers to Subroutines: sub_108C46 sub_1090B8 sub_1090C2
Subroutine sub_108E0E Refers to Scalars: $13C03E $13C03E $13C03E $13C03E $13C03E $13C03E $13C03E
Subroutine sub_109038 Refers to Subroutines: sub_1090B8
Subroutine sub_10907E Refers to Subroutines: sub_109090
Subroutine sub_109090 Refers to Subroutines: sub_10907E sub_1090B8
Subroutine sub_10910C Refers to Subroutines: sub_102B86 sub_105FAA
Subroutine sub_1091A0 Refers to Subroutines: sub_109200 sub_109212
Subroutine sub_109200 Refers to Subroutines: sub_1091A0
Subroutine sub_109212 Refers to Subroutines: sub_104E28 sub_1063C2 sub_107722 sub_10820E sub_1091A0 sub_10939C sub_1094E4
Subroutine sub_10939C Refers to Subroutines: sub_109518 sub_109536 sub_109554 sub_109570 sub_1095CC sub_109600 sub_10962E
Subroutine sub_1094E4 Refers to Subroutines: sub_10962E sub_109642
Subroutine sub_109518 Refers to Subroutines: sub_109642
Subroutine sub_109536 Refers to Subroutines: sub_109642
Subroutine sub_109554 Refers to Subroutines: sub_109642
Subroutine sub_109642 Refers to Subroutines: sub_1094E4
Subroutine sub_109654 Refers to Subroutines: sub_1007F8 sub_10147C sub_101730 sub_101F40 sub_101F9C sub_10204A sub_1020E0 sub_102850 sub_1034E4 sub_104450 sub_1045E2 sub_105634 sub_1063C2 sub_107228
Subroutine sub_110414 Refers to Subroutines: sub_110426 sub_110810
Subroutine sub_110426 Refers to Subroutines: sub_110414 sub_11045E sub_1105B6 sub_110624
Subroutine sub_11045E Refers to Scalars: $13C16E
Subroutine sub_1104AA Refers to Subroutines: sub_110A60
Subroutine sub_1104FA Refers to Subroutines: sub_110668 sub_110706 sub_110A60
Subroutine sub_1104FA Refers to Scalars: $13C764
Subroutine sub_1105B6 Refers to Subroutines: sub_110668 sub_110706
Subroutine sub_1105B6 Refers to Scalars: $13C734
Subroutine sub_110624 Refers to Subroutines: sub_110668 sub_110706
Subroutine sub_110624 Refers to Scalars: $13C16E
Subroutine sub_110668 Refers to Subroutines: sub_1104FA sub_1105B6
Subroutine sub_110668 Refers to Scalars: $13C018
Subroutine sub_110706 Refers to Subroutines: sub_1104FA sub_115D2C
Subroutine sub_110706 Refers to Tables: 7 3 5 4 6 8
Subroutine sub_110810 Refers to Subroutines: sub_110414
Subroutine sub_110810 Refers to Scalars: $13C11C $13C170
Subroutine sub_11086A Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_11086A Refers to Scalars: $13C1A6 $13C1A8
Subroutine sub_1109BE Refers to Subroutines: sub_111120 sub_114D46 sub_1153BC sub_1195C0 sub_11963C sub_119A58
Subroutine sub_110A28 Refers to Subroutines: sub_111334 sub_115018 sub_115418
Subroutine sub_110A60 Refers to Subroutines: sub_1104AA sub_1104FA sub_111358 sub_115B68 sub_119C2C sub_11A536 sub_11AC22 sub_11EBD0 sub_121420 sub_129D24 sub_12A35E sub_12A8F4 sub_12AC54 sub_12AF48 sub_12B328 sub_12B330 sub_12E4EC sub_132710 sub_132A02
Subroutine sub_110A60 Refers to Scalars: $13C1A8 $13C1A6 $13CA6C $13C192 $13C194 $13C59C
Subroutine sub_110CDE Refers to Subroutines: sub_110D4A sub_110FCC sub_12A35E
Subroutine sub_110D06 Refers to Subroutines: sub_110FCC
Subroutine sub_110D2A Refers to Subroutines: sub_119A58 sub_119B08
Subroutine sub_110D4A Refers to Subroutines: sub_110CC8 sub_110FCC sub_111078 sub_111112 sub_111120 sub_1112C0 sub_1112D6 sub_111334 sub_111358 sub_111388 sub_115C20
Subroutine sub_110D4A Refers to Scalars: $13C1AA $13C1AA
Subroutine sub_110FCC Refers to Subroutines: sub_110CDE sub_110D06 sub_115C20 sub_1195C0 sub_11963C
Subroutine sub_110FCC Refers to Scalars: $13C120 $13C1AC
Subroutine sub_111078 Refers to Scalars: $13C01A $13C01A $13C1AE
Subroutine sub_111120 Refers to Subroutines: sub_1109BE sub_1195C0 sub_11963C
Subroutine sub_111120 Refers to Scalars: $13C83C $13C83C $13C83E $13C842 $13C840 $13C846 $13C844
Subroutine sub_1112D6 Refers to Scalars: $13C1B0 $13C1B2
Subroutine sub_111334 Refers to Subroutines: sub_110A28
Subroutine sub_111358 Refers to Subroutines: sub_110A60
Subroutine sub_111388 Refers to Scalars: $13C1B6
Subroutine sub_111422 Refers to Subroutines: sub_113FD0
Subroutine sub_11143E Refers to Subroutines: sub_1115E6
Subroutine sub_1114A4 Refers to Subroutines: sub_1115E6 sub_11165C
Subroutine sub_1114A4 Refers to Scalars: $13C1D6 $13C1D8 $13C1DA $13C1E0 $13C1DC $13C1DE $13C1CA $13C1CC $13C1CE $13C1CC $13C1BE $13C1C0 $13C1C2 $13C1D0 $13C1D2 $13C1D4
Subroutine sub_1115E6 Refers to Subroutines: sub_11143E
Subroutine sub_11165C Refers to Subroutines: sub_1114A4 sub_1119EE sub_111D4C sub_112172 sub_116DAA sub_11862E sub_11878C sub_118BA2
Subroutine sub_1116D0 Refers to Subroutines: sub_111A9C
Subroutine sub_1116D6 Refers to Subroutines: sub_1116E0 sub_111ED6
Subroutine sub_1116E0 Refers to Subroutines: sub_1116D6 sub_1121EE sub_112210 sub_112234 sub_112246 sub_112258 sub_11226A sub_116818 sub_118988 sub_121CB8 sub_121CCA
Subroutine sub_1116E0 Refers to Scalars: $13C1F0 $13C1F2 $13C1F4 $13C1F0 $13C1F2
Subroutine sub_1119EE Refers to Subroutines: sub_112278 sub_112318 sub_125030 sub_1254EE
Subroutine sub_111A9C Refers to Subroutines: sub_1116D0 sub_112278 sub_1122AE sub_1122BC sub_1122E6
Subroutine sub_111A9C Refers to Scalars: $13C1EE $13C200
Subroutine sub_111D4C Refers to Subroutines: sub_112234 sub_112246 sub_112278 sub_11228A sub_1122E6
Subroutine sub_111D4C Refers to Scalars: $13C1FC $13C1FE
Subroutine sub_111ED6 Refers to Subroutines: sub_1116D6 sub_112278 sub_1122C2 sub_1122CA sub_1122D2 sub_1122DA
Subroutine sub_111ED6 Refers to Scalars: $13C1E2 $13C1E4 $13C1E4 $13C1E6 $13C1EA $13C1E8 $13C1F0 $13C1F2
Subroutine sub_112234 Refers to Scalars: $13C124
Subroutine sub_112246 Refers to Scalars: $13C124
Subroutine sub_112278 Refers to Subroutines: sub_1119EE
Subroutine sub_11228A Refers to Subroutines: sub_111D4C
Subroutine sub_11228A Refers to Scalars: $13C1FA $13C1F6 $13C1F8 $13C1F8
Subroutine sub_112318 Refers to Subroutines: sub_1119EE
Subroutine sub_112482 Refers to Scalars: $13C202
Subroutine sub_1125D6 Refers to Scalars: $13C01C
Subroutine sub_1126F0 Refers to Scalars: $13C01E $13C01E
Subroutine sub_1127F8 Refers to Subroutines: sub_112820 sub_112ACE sub_112B12 sub_112C54 sub_112C82 sub_11ACCA
Subroutine sub_1127F8 Refers to Scalars: $13C206
Subroutine sub_112820 Refers to Subroutines: sub_1127F8 sub_112914 sub_112972 sub_11298A
Subroutine sub_112820 Refers to Scalars: $13C21A $13C208
Subroutine sub_112914 Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_112972 Refers to Scalars: $13C206
Subroutine sub_11298A Refers to Subroutines: sub_1129F2 sub_112A34 sub_12C5C2
Subroutine sub_11298A Refers to Scalars: $13C212
Subroutine sub_112A34 Refers to Scalars: $13C21C $13C21E $13C212 $13C212 $13C220 $13C20A
Subroutine sub_112ACE Refers to Subroutines: sub_1127F8
Subroutine sub_112ACE Refers to Scalars: $13C218
Subroutine sub_112B12 Refers to Subroutines: sub_1127F8 sub_112CAE
Subroutine sub_112B12 Refers to Scalars: $13C20C $13C20E $13C222 $13C224 $13C20E
Subroutine sub_112C54 Refers to Subroutines: sub_1127F8
Subroutine sub_112C54 Refers to Scalars: $13C210
Subroutine sub_112C82 Refers to Subroutines: sub_1127F8
Subroutine sub_112C82 Refers to Scalars: $13C216 $13C214
Subroutine sub_112CAE Refers to Scalars: $13C20A $13C212
Subroutine sub_112CCE Refers to Scalars: $13C226
Subroutine sub_112E1E Refers to Subroutines: sub_118CEE sub_11ACDE
Subroutine sub_112E1E Refers to Scalars: $13C22A $13C22C $13C22E $13C234 $13C276 $13C236 $13C238 $13C23A $13C23E $13C23C $13C240 $13C230 $13C232 $13C242
Subroutine sub_113258 Refers to Subroutines: sub_113268 sub_11346A sub_116056
Subroutine sub_113268 Refers to Subroutines: sub_113258 sub_113B06 sub_113B20 sub_113B8C sub_113BB6 sub_113C12 sub_113CC4 sub_113D3E sub_113D82 sub_113E40 sub_113E6E sub_113EE0 sub_113F0A sub_113F3E
Subroutine sub_11346A Refers to Subroutines: sub_113258 sub_113B06 sub_113B20 sub_113B8C sub_113C12 sub_113C34 sub_113C68 sub_113C98 sub_113CAC sub_113DDA sub_113E10 sub_113E52 sub_113EA4 sub_113EB6 sub_113EC4 sub_113ED2 sub_113F6C sub_113F84 sub_113F96 sub_113FA4 sub_113FBE
Subroutine sub_11346A Refers to Scalars: $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020 $13C020
Subroutine sub_113ABA Refers to Subroutines: sub_113CC4
Subroutine sub_113BCA Refers to Subroutines: sub_113C34 sub_113C98
Subroutine sub_113C34 Refers to Subroutines: sub_113BCA
Subroutine sub_113C98 Refers to Subroutines: sub_113BCA
Subroutine sub_113CAC Refers to Subroutines: sub_113BCA
Subroutine sub_113CC4 Refers to Subroutines: sub_113ABA
Subroutine sub_113D3E Refers to Subroutines: sub_113ABA
Subroutine sub_113D82 Refers to Subroutines: sub_113ABA
Subroutine sub_113DDA Refers to Subroutines: sub_113BCA
Subroutine sub_113E40 Refers to Subroutines: sub_113ABA
Subroutine sub_113E52 Refers to Subroutines: sub_113BCA
Subroutine sub_113E6E Refers to Subroutines: sub_113ABA
Subroutine sub_113EA4 Refers to Subroutines: sub_113BCA
Subroutine sub_113EE0 Refers to Subroutines: sub_113ABA
Subroutine sub_113F0A Refers to Subroutines: sub_113ABA
Subroutine sub_113F3E Refers to Subroutines: sub_113ABA
Subroutine sub_113F6C Refers to Subroutines: sub_113BCA
Subroutine sub_113F84 Refers to Subroutines: sub_113BCA
Subroutine sub_113F96 Refers to Subroutines: sub_113BCA
Subroutine sub_113FA4 Refers to Subroutines: sub_113BCA
Subroutine sub_113FBE Refers to Subroutines: sub_113BCA
Subroutine sub_113FD0 Refers to Subroutines: sub_111422
Subroutine sub_113FFA Refers to Subroutines: sub_114252
Subroutine sub_11418C Refers to Subroutines: sub_114216 sub_114252
Subroutine sub_114216 Refers to Subroutines: sub_11418C
Subroutine sub_114252 Refers to Subroutines: sub_113FFA sub_11418C
Subroutine sub_114270 Refers to Subroutines: sub_1142E8 sub_1143D8
Subroutine sub_1142E8 Refers to Subroutines: sub_114270 sub_1220E2
Subroutine sub_11433C Refers to Subroutines: sub_1143D8
Subroutine sub_1143D8 Refers to Subroutines: sub_114270 sub_1220E2
Subroutine sub_114468 Refers to Subroutines: sub_114498 sub_114A92
Subroutine sub_114480 Refers to Subroutines: sub_1144F6 sub_114A92
Subroutine sub_114498 Refers to Subroutines: sub_114468 sub_114554
Subroutine sub_1144F6 Refers to Subroutines: sub_114480 sub_114554
Subroutine sub_114554 Refers to Subroutines: sub_11442E sub_114498 sub_1144F6
Subroutine sub_1145B2 Refers to Subroutines: sub_114554
Subroutine sub_1145B2 Refers to Scalars: $13C014 $13C014
Subroutine sub_1146C4 Refers to Subroutines: sub_114800 sub_114812
Subroutine sub_114784 Refers to Subroutines: sub_1232D8
Subroutine sub_1147B2 Refers to Subroutines: sub_1232D8
Subroutine sub_114800 Refers to Subroutines: sub_114812
Subroutine sub_114812 Refers to Subroutines: sub_114800 sub_1148B8 sub_1148F4 sub_114A92
Subroutine sub_1149A4 Refers to Subroutines: sub_114A92
Subroutine sub_114A92 Refers to Subroutines: sub_114468 sub_114480
Subroutine sub_114AB4 Refers to Subroutines: sub_114B2C sub_114BC6
Subroutine sub_114B2C Refers to Subroutines: sub_114AB4 sub_114BC6 sub_1220E2
Subroutine sub_114BC6 Refers to Subroutines: sub_114AB4 sub_1220E2
Subroutine sub_114C24 Refers to Subroutines: sub_1246C8
Subroutine sub_114C54 Refers to Subroutines: sub_114D46 sub_114DB8 sub_114DCA sub_114E08 sub_114E72 sub_114EA2 sub_114F72
Subroutine sub_114D46 Refers to Subroutines: sub_1109BE
Subroutine sub_114D46 Refers to Scalars: $13C46C
Subroutine sub_114DDC Refers to Subroutines: sub_115018
Subroutine sub_114E08 Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_114E08 Refers to Scalars: $13C08A $13C094
Subroutine sub_114E72 Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_114EA2 Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_114ED6 Refers to Scalars: $13C08C $13C08C $13C096 $13C08A $13C096 $13C096
Subroutine sub_114F72 Refers to Subroutines: sub_115D2C
Subroutine sub_114F72 Refers to Tables: 129
Subroutine sub_114F72 Refers to Scalars: $13C090 $13C08E
Subroutine sub_114FDC Refers to Subroutines: sub_121070
Subroutine sub_115018 Refers to Subroutines: sub_110A28 sub_114DDC sub_114ED6
Subroutine sub_11506E Refers to Subroutines: sub_115086
Subroutine sub_115086 Refers to Subroutines: sub_11506E sub_1151BA sub_115456 sub_115482 sub_1154CA
Subroutine sub_1151BA Refers to Subroutines: sub_1195C0 sub_11963C
Subroutine sub_1151BA Refers to Scalars: $13C68E
Subroutine sub_11521A Refers to Subroutines: sub_130052
Subroutine sub_11521A Refers to Scalars: $13CAA5 $13CAA5
Subroutine sub_11533E Refers to Subroutines: sub_11F556 sub_12F146
Subroutine sub_11533E Refers to Scalars: $13C46E $13C194
Subroutine sub_1153BC Refers to Subroutines: sub_1109BE
Subroutine sub_115418 Refers to Subroutines: sub_110A28
Subroutine sub_1154CA Refers to Subroutines: sub_115534
Subroutine sub_115534 Refers to Subroutines: sub_110414 sub_1104FA sub_11086A sub_110D06 sub_111422 sub_11143E sub_1114A4 sub_1116D6 sub_112482 sub_1125D6 sub_1126F0 sub_1127F8 sub_112CCE sub_112E1E sub_1145B2 sub_114C54 sub_11506E sub_1158BE sub_115E1E sub_116056 sub_116572 sub_1167F0 sub_119076 sub_119524 sub_119734 sub_11AC7C sub_1255A6 sub_1261C8 sub_12C926 sub_1313AA sub_135582
Subroutine sub_115534 Refers to Scalars: $13CAA5 $13CAA5 $13C472 $13C098 $13C09A
Subroutine sub_1158F6 Refers to Subroutines: sub_115B2E sub_11DB84
Subroutine sub_115B2E Refers to Subroutines: sub_1158F6
Subroutine sub_115B68 Refers to Subroutines: sub_110A60
Subroutine sub_115B68 Refers to Scalars: $13C09C
Subroutine sub_115C30 Refers to Subroutines: sub_119D80
Subroutine sub_115C4E Refers to Subroutines: sub_11DB84 sub_11DD78
Subroutine sub_115D2C Refers to Subroutines: sub_110706
Subroutine sub_115E1E Refers to Subroutines: sub_1108F8 sub_1116D0 sub_11246A sub_115F78 sub_116AF6 sub_118BCE sub_119092 sub_119C9A sub_11AD44 sub_129514 sub_12C242 sub_12C9F0 sub_12F250 sub_132AA2
Subroutine sub_115F78 Refers to Subroutines: sub_11604E
Subroutine sub_116056 Refers to Subroutines: sub_113258 sub_11606C
Subroutine sub_11606C Refers to Subroutines: sub_116056 sub_1163BE sub_1163C6 sub_11641E sub_116426 sub_11642E sub_11645A sub_116486 sub_1164A2 sub_1164BA sub_1164EC sub_116560
Subroutine sub_11606C Refers to Scalars: $13CAA2 $13CAA2 $13CAA1 $13CAA1 $13CAA1
Subroutine sub_116572 Refers to Subroutines: sub_1166C4 sub_1166CC sub_1166D4 sub_1166E4
Subroutine sub_116572 Refers to Scalars: $13C678 $13C67A $13C67C $13C67C $13C67C
Subroutine sub_1166EC Refers to Subroutines: sub_116ED0 sub_1174D8 sub_117890 sub_11798A sub_1179A2 sub_117E8A sub_117F96
Subroutine sub_116764 Refers to Subroutines: sub_116ED0
Subroutine sub_116764 Refers to Scalars: $13C0FB $13C0FC $13C0FD
Subroutine sub_1167B2 Refers to Subroutines: sub_116ED0
Subroutine sub_116AF6 Refers to Scalars: $13C0A2 $13C0A4 $13C0B6 $13C0A8 $13C0A6 $13C0A8 $13C0B8 $13C0AC $13C0AA $13C0AC $13C0B8 $13C0B0 $13C0B0 $13C0B8 $13C0AE $13C0B0 $13C0B4 $13C0B0
Subroutine sub_116DAA Refers to Scalars: $13C0B6 $13C0B2 $13C0B8 $13C0B2 $13C0B8 $13C0B2 $13C0B8 $13C0B2 $13C0B4
Subroutine sub_116ED0 Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2 sub_132204
Subroutine sub_116ED0 Refers to Scalars: $13C0FE $13C0FF $13C100 $13C101 $13C102 $13C103 $13C104
Subroutine sub_1174D8 Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2 sub_132250
Subroutine sub_1174D8 Refers to Scalars: $13C105 $13C106 $13C107 $13C108
Subroutine sub_117890 Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2
Subroutine sub_11798A Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2 sub_1246C8
Subroutine sub_1179A2 Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2
Subroutine sub_1179A2 Refers to Scalars: $13C109 $13C10A $13C10B $13C10C $13CAA6 $13CAA7 $13C5BE $13C5BE $13CAA7 $13C5C0 $13C5C0 $13CAA8 $13CAA8 $13C5C6 $13C5C6 $13CAA9 $13C5BE $13C5BE $13CAA9 $13C5C0 $13C5C0 $13CAAA $13C542 $13C542 $13C542 $13C542
Subroutine sub_117E8A Refers to Subroutines: sub_1166EC sub_116764 sub_1167B2
Subroutine sub_117F96 Refers to Subroutines: sub_114270 sub_1166EC sub_116764 sub_1167B2 sub_1185E8 sub_11860C
Subroutine sub_117F96 Refers to Scalars: $13C10D $13C10E $13C10F $13C110
Subroutine sub_1185E8 Refers to Subroutines: sub_117F96
Subroutine sub_11860C Refers to Subroutines: sub_117F96
Subroutine sub_11862E Refers to Scalars: $13C0BC $13C0BC
Subroutine sub_11878C Refers to Scalars: $13C111 $13C0BA $13C112 $13C0BA $13C113 $13C0BA $13C0BA $13C0BA $13C0BA $13C0BA $13C0BA
Subroutine sub_118988 Refers to Subroutines: sub_1166EC sub_1186A4 sub_1186C2
Subroutine sub_118988 Refers to Scalars: $13C0C2 $13C0C0 $13C0C2 $13C0C2 $13C0C0 $13C0BE $13C0C2 $13C0C0 $13C0BC
Subroutine sub_118BCE Refers to Subroutines: sub_118C92
Subroutine sub_118BCE Refers to Scalars: $13C0C6
Subroutine sub_118CD6 Refers to Subroutines: sub_115D2C sub_119076
Subroutine sub_118CD6 Refers to Tables: 158
Subroutine sub_118CEE Refers to Subroutines: sub_112E1E sub_118D08 sub_118D8A sub_118E0C sub_118E32 sub_118E50 sub_118E70
Subroutine sub_118D08 Refers to Subroutines: sub_118CEE sub_118D82
Subroutine sub_118D8A Refers to Subroutines: sub_118CEE sub_118E04
Subroutine sub_118E0C Refers to Subroutines: sub_118CEE
Subroutine sub_118E0C Refers to Scalars: $13C0C8
Subroutine sub_118E32 Refers to Subroutines: sub_118CEE
Subroutine sub_118E50 Refers to Subroutines: sub_118CEE
Subroutine sub_118E70 Refers to Subroutines: sub_118CEE sub_118F14 sub_118F22 sub_118F30
Subroutine sub_118F22 Refers to Scalars: $13C0C8
Subroutine sub_118F30 Refers to Scalars: $13C0C8
Subroutine sub_118F3E Refers to Subroutines: sub_11904C sub_11905C sub_119068 sub_119092
Subroutine sub_118F3E Refers to Scalars: $13C0CA $13C0CA
Subroutine sub_119076 Refers to Subroutines: sub_118CD6 sub_1190AC sub_1190D2 sub_11936A sub_11937C
Subroutine sub_119092 Refers to Subroutines: sub_118F3E sub_119136 sub_11913E sub_1191E2
Subroutine sub_1190AC Refers to Subroutines: sub_119076
Subroutine sub_1190D2 Refers to Subroutines: sub_119076
Subroutine sub_119136 Refers to Subroutines: sub_119092
Subroutine sub_11913E Refers to Subroutines: sub_119092
Subroutine sub_1191E2 Refers to Subroutines: sub_119092 sub_119166 sub_1191CE
Subroutine sub_1191E2 Refers to Scalars: $13C0CC $13C6EE $13C6EE $13C6EE
Subroutine sub_11936A Refers to Subroutines: sub_119076
Subroutine sub_11937C Refers to Subroutines: sub_119076 sub_11949C sub_1194AA sub_1194C4 sub_1194D2 sub_1194E0 sub_119516
Subroutine sub_11949C Refers to Scalars: $13C0C8
Subroutine sub_1194AA Refers to Scalars: $13C0D0 $13C0D2
Subroutine sub_1194C4 Refers to Scalars: $13C0C8
Subroutine sub_1194D2 Refers to Scalars: $13C0D4
Subroutine sub_1194E0 Refers to Scalars: $13C0D0 $13C0C8
Subroutine sub_119524 Refers to Subroutines: sub_11957C sub_1195C0
Subroutine sub_11957C Refers to Subroutines: sub_119524
Subroutine sub_1195C0 Refers to Subroutines: sub_11086A sub_1109BE
Subroutine sub_11963C Refers to Subroutines: sub_11086A sub_1109BE sub_1196AE sub_1196BE sub_1197AC
Subroutine sub_119734 Refers to Subroutines: sub_119BC4 sub_119BF2
Subroutine sub_119734 Refers to Scalars: $13C706
Subroutine sub_1197AC Refers to Subroutines: sub_119B08 sub_119B8C sub_119BBC sub_119BC4 sub_119BDE sub_119BF2
Subroutine sub_119A58 Refers to Subroutines: sub_1109BE sub_110D2A sub_119A9C
Subroutine sub_119A58 Refers to Scalars: $13C70C $13C70E
Subroutine sub_119A9C Refers to Subroutines: sub_119A58 sub_119B08
Subroutine sub_119A9C Refers to Scalars: $13CA84 $13C70E $13C70E
Subroutine sub_119B08 Refers to Subroutines: sub_110D2A sub_119A9C
Subroutine sub_119B08 Refers to Scalars: $13C708 $13C70A $13C70C $13C70E $13C70A
Subroutine sub_119B8C Refers to Scalars: $13C712 $13C710
Subroutine sub_119BC4 Refers to Subroutines: sub_119734
Subroutine sub_119BF2 Refers to Subroutines: sub_1195C0 sub_11963C sub_119734
Subroutine sub_119C2C Refers to Subroutines: sub_110A60 sub_119D24
Subroutine sub_119C9A Refers to Subroutines: sub_119D24
Subroutine sub_119D24 Refers to Subroutines: sub_119C2C
Subroutine sub_119D6C Refers to Subroutines: sub_119D80 sub_11A376 sub_11A4D8 sub_11A6C6 sub_1255A6
Subroutine sub_119D80 Refers to Subroutines: sub_115C30 sub_115D2C sub_119D6C sub_11A536
Subroutine sub_119D80 Refers to Tables: 2
Subroutine sub_119D80 Refers to Scalars: $13C144 $13C144 $13C152 $13C146 $13C164 $13C77C $13C77C $13C154 $13C162 $13C77C $13C156 $13C166 $13C77C $13C168 $13C77C $13C15A $13C77C $13C158 $13C77C $13C15C $13C77C $13C77C $13C15E $13C77C $13C160
Subroutine sub_11A376 Refers to Subroutines: sub_119D6C sub_11A45C sub_11A494 sub_11A49C sub_11A4A4
Subroutine sub_11A376 Refers to Scalars: $13C148 $13C148 $13C14C $13C148
Subroutine sub_11A45C Refers to Scalars: $13C14A $13C14C $13C14C
Subroutine sub_11A4A4 Refers to Scalars: $13C14E
Subroutine sub_11A4D8 Refers to Subroutines: sub_119D6C
Subroutine sub_11A536 Refers to Subroutines: sub_110A60 sub_115D2C sub_119D80 sub_11A654
Subroutine sub_11A536 Refers to Tables: 1
Subroutine sub_11A536 Refers to Scalars: $13C150 $13C72E $13C730 $13C732 $13C16A $13C16C
Subroutine sub_11A654 Refers to Subroutines: sub_11A536
Subroutine sub_11A654 Refers to Scalars: $13C724 $13C726 $13C728 $13C72A $13C71E $13C720 $13C722
Subroutine sub_11A6C6 Refers to Subroutines: sub_119D6C sub_11A7AA sub_11A7E2 sub_11A7EA sub_11A81E
Subroutine sub_11A6C6 Refers to Scalars: $13C172 $13C172 $13C174 $13C172
Subroutine sub_11A7AA Refers to Scalars: $13C176 $13C174 $13C174
Subroutine sub_11A7EA Refers to Scalars: $13C178
Subroutine sub_11A826 Refers to Subroutines: sub_115D2C sub_11A896
Subroutine sub_11A826 Refers to Tables: 84
Subroutine sub_11A826 Refers to Scalars: $13C17A $13C17C $13C17A
Subroutine sub_11A896 Refers to Subroutines: sub_11A826 sub_11A8D6 sub_11AA1C sub_11AA84 sub_1255A6
Subroutine sub_11A896 Refers to Scalars: $13C17A
Subroutine sub_11A8D6 Refers to Subroutines: sub_11A896 sub_11AA34 sub_11AA54
Subroutine sub_11A8D6 Refers to Scalars: $13C182 $13C17E $13C180 $13C180
Subroutine sub_11AA1C Refers to Subroutines: sub_115D2C sub_11A896
Subroutine sub_11AA1C Refers to Tables: 85
Subroutine sub_11AA34 Refers to Subroutines: sub_115D2C sub_11AA62
Subroutine sub_11AA34 Refers to Tables: 9
Subroutine sub_11AA34 Refers to Scalars: $13C188
Subroutine sub_11AA54 Refers to Subroutines: sub_11AA62
Subroutine sub_11AA54 Refers to Scalars: $13C186
Subroutine sub_11AA62 Refers to Subroutines: sub_115C30 sub_11AA34 sub_11AA54
Subroutine sub_11AA84 Refers to Subroutines: sub_11A896
Subroutine sub_11AA84 Refers to Scalars: $13C184
Subroutine sub_11AB38 Refers to Subroutines: sub_11ABE8 sub_11ABFC sub_11AC14 sub_1255A6
Subroutine sub_11AB38 Refers to Scalars: $13C18A $13C18E $13C18C $13C18A $13C18A
Subroutine sub_11ABE8 Refers to Subroutines: sub_115D2C
Subroutine sub_11ABE8 Refers to Tables: 10
Subroutine sub_11ABFC Refers to Subroutines: sub_115D2C
Subroutine sub_11ABFC Refers to Tables: 86
Subroutine sub_11AC14 Refers to Scalars: $13C190
Subroutine sub_11AC22 Refers to Subroutines: sub_110A60
Subroutine sub_11AC7C Refers to Scalars: $13C1B4
Subroutine sub_11ACCA Refers to Subroutines: sub_1127F8
Subroutine sub_11ACDE Refers to Subroutines: sub_112E1E
Subroutine sub_11ACDE Refers to Scalars: $13C228
Subroutine sub_11AD44 Refers to Scalars: $13C244 $13C246
Subroutine sub_11ADF2 Refers to Subroutines: sub_1255A6
Subroutine sub_11ADF2 Refers to Scalars: $13C24A $13C248
Subroutine sub_11AEEE Refers to Subroutines: sub_11AEF4 sub_1255A6
Subroutine sub_11AEF4 Refers to Subroutines: sub_11AEEE
Subroutine sub_11AEF4 Refers to Scalars: $13C24C $13C25C $13C24E $13C250 $13C252 $13C24E $13C250 $13C24E $13C250 $13C256 $13C256 $13C25A $13C258 $13C256 $13C25A $13C254
Subroutine sub_11B0EE Refers to Subroutines: sub_1255A6
Subroutine sub_11B10A Refers to Subroutines: sub_115D2C
Subroutine sub_11B10A Refers to Tables: 87 11 12
Subroutine sub_11B10A Refers to Scalars: $13C266 $13C26A $13C264 $13C268 $13C26C
Subroutine sub_11B22A Refers to Subroutines: sub_115D2C sub_11B33A
Subroutine sub_11B22A Refers to Tables: 13
Subroutine sub_11B22A Refers to Scalars: $13C272 $13C270 $13C26E
Subroutine sub_11B33A Refers to Subroutines: sub_11B22A sub_11B36A sub_11B564 sub_11B7EE sub_11B8B4 sub_11B99A sub_11BCDE sub_11C266 sub_1255A6
Subroutine sub_11B36A Refers to Subroutines: sub_11B10A sub_11B33A sub_11BAD2 sub_11BD9E
Subroutine sub_11B36A Refers to Scalars: $13C276 $13C274 $13C274 $13C274 $13C276 $13C274 $13C276 $13C274 $13C276 $13C274 $13C276 $13C274 $13C276 $13C274
Subroutine sub_11B564 Refers to Subroutines: sub_11B33A sub_11B748 sub_11B79E
Subroutine sub_11B564 Refers to Scalars: $13C284 $13C284 $13C284 $13C286 $13C282 $13C284
Subroutine sub_11B748 Refers to Subroutines: sub_115D2C
Subroutine sub_11B748 Refers to Tables: 110 109
Subroutine sub_11B748 Refers to Scalars: $13C288 $13C0D0 $13C0C8
Subroutine sub_11B79E Refers to Subroutines: sub_115D2C
Subroutine sub_11B79E Refers to Tables: 110 109
Subroutine sub_11B79E Refers to Scalars: $13C28A $13C28C
Subroutine sub_11B7EE Refers to Subroutines: sub_11B33A sub_11B8AC
Subroutine sub_11B7EE Refers to Scalars: $13C28E
Subroutine sub_11B8B4 Refers to Subroutines: sub_11B33A
Subroutine sub_11B8B4 Refers to Scalars: $13C290 $13C292 $13C296 $13C294 $13C298 $13C290
Subroutine sub_11B99A Refers to Subroutines: sub_11B33A sub_11BACA
Subroutine sub_11B99A Refers to Scalars: $13C29C $13C29A
Subroutine sub_11BAD2 Refers to Subroutines: sub_11BC94 sub_11BCB6
Subroutine sub_11BAD2 Refers to Scalars: $13C29E
Subroutine sub_11BC94 Refers to Scalars: $13C2A2 $13C28C
Subroutine sub_11BCB6 Refers to Scalars: $13C2A0 $13C0D0 $13C0C8
Subroutine sub_11BCDE Refers to Subroutines: sub_11B33A
Subroutine sub_11BCDE Refers to Scalars: $13C2A4 $13C2A8 $13C2A6 $13C2A4
Subroutine sub_11BD9E Refers to Subroutines: sub_11C1CE sub_11C1F8 sub_11C222 sub_11C244
Subroutine sub_11BD9E Refers to Scalars: $13C2B2 $13C29E $13C29E $13C2B2
Subroutine sub_11C1CE Refers to Scalars: $13C2AC $13C0D0 $13C0D0 $13C0C8
Subroutine sub_11C1F8 Refers to Scalars: $13C2AA $13C0D0 $13C0D0 $13C0C8
Subroutine sub_11C222 Refers to Scalars: $13C2AE $13C28C
Subroutine sub_11C244 Refers to Scalars: $13C2B0 $13C28C
Subroutine sub_11C266 Refers to Subroutines: sub_11B33A sub_11C270 sub_11C448
Subroutine sub_11C270 Refers to Subroutines: sub_11C266
Subroutine sub_11C270 Refers to Scalars: $13C2C6 $13C2CA $13C2BE $13C2C0 $13C2C6 $13C2C8 $13C2CA $13C2CC $13C2C2 $13C2C4
Subroutine sub_11C448 Refers to Subroutines: sub_11C266
Subroutine sub_11C448 Refers to Scalars: $13C2B6 $13C2B6 $13C2BA $13C2B8 $13C2B6 $13C2BC $13C2B4 $13C2BC
Subroutine sub_11C5D6 Refers to Subroutines: sub_11C756
Subroutine sub_11C5D6 Refers to Scalars: $13C2D8 $13C2DA $13C2CE $13C2D0 $13C2D2
Subroutine sub_11C782 Refers to Subroutines: sub_11C834
Subroutine sub_11C782 Refers to Scalars: $13C2D6
Subroutine sub_11C834 Refers to Scalars: $13C2D4
Subroutine sub_11C84C Refers to Subroutines: sub_11C5D6 sub_11C782 sub_11C914 sub_11CD5C sub_11D4E0
Subroutine sub_11C924 Refers to Subroutines: sub_11CB68 sub_11CBAE
Subroutine sub_11C924 Refers to Scalars: $13C2DE $13C2DC $13C2DE $13C2DC $13C2DE $13C2DC $13C2DE $13C2DC $13C2DE $13C2DC
Subroutine sub_11CB68 Refers to Subroutines: sub_115D2C
Subroutine sub_11CB68 Refers to Tables: 89
Subroutine sub_11CB68 Refers to Scalars: $13C2D8
Subroutine sub_11CBAE Refers to Subroutines: sub_115D2C
Subroutine sub_11CBAE Refers to Tables: 90
Subroutine sub_11CBAE Refers to Scalars: $13C2DA
Subroutine sub_11CBF4 Refers to Subroutines: sub_11CCE4 sub_11CD00 sub_11CD50 sub_11CD5C
Subroutine sub_11CD00 Refers to Scalars: $13C2E0
Subroutine sub_11CD5C Refers to Subroutines: sub_11C84C sub_11CBF4 sub_11CDAC sub_11CF12 sub_11CF64 sub_11CFB4 sub_11D0EE sub_11D164 sub_11D246 sub_11D3C8 sub_1255A6
Subroutine sub_11CDAC Refers to Subroutines: sub_11CD5C
Subroutine sub_11CDAC Refers to Scalars: $13C2E6 $13C2F4 $13C2F6
Subroutine sub_11CF12 Refers to Subroutines: sub_11CD5C
Subroutine sub_11CF12 Refers to Scalars: $13C2E2
Subroutine sub_11CF64 Refers to Subroutines: sub_11CD5C
Subroutine sub_11CF64 Refers to Scalars: $13C2E4
Subroutine sub_11CFB4 Refers to Subroutines: sub_11CD5C sub_11D004
Subroutine sub_11D004 Refers to Subroutines: sub_115D2C
Subroutine sub_11D004 Refers to Tables: 16 16
Subroutine sub_11D038 Refers to Subroutines: sub_11D0B8
Subroutine sub_11D038 Refers to Scalars: $13C2E8 $13C2E8
Subroutine sub_11D0B8 Refers to Subroutines: sub_115D2C
Subroutine sub_11D0B8 Refers to Tables: 91
Subroutine sub_11D0B8 Refers to Scalars: $13C2DA
Subroutine sub_11D0EE Refers to Subroutines: sub_11CD5C
Subroutine sub_11D0EE Refers to Scalars: $13C2EA $13C2EA
Subroutine sub_11D164 Refers to Subroutines: sub_11CD5C
Subroutine sub_11D164 Refers to Scalars: $13C2EC
Subroutine sub_11D246 Refers to Subroutines: sub_11CD5C
Subroutine sub_11D246 Refers to Scalars: $13C2EE $13C2F0 $13C2F2 $13C2F8 $13C2FA $13C2FC $13C2F4 $13C2F6
Subroutine sub_11D3C8 Refers to Subroutines: sub_11CD5C
Subroutine sub_11D3C8 Refers to Scalars: $13C2F4 $13C300 $13C2FE
Subroutine sub_11D4E0 Refers to Subroutines: sub_11C924 sub_11CB68 sub_11CBAE sub_11CCA0 sub_11D038 sub_11D7F0 sub_11D7FC sub_11D808
Subroutine sub_11D4E0 Refers to Scalars: $13C302 $13C302
Subroutine sub_11D808 Refers to Subroutines: sub_11D888
Subroutine sub_11D808 Refers to Scalars: $13C304 $13C304
Subroutine sub_11D888 Refers to Subroutines: sub_115D2C
Subroutine sub_11D888 Refers to Tables: 92
Subroutine sub_11D888 Refers to Scalars: $13C2D8
Subroutine sub_11D8BE Refers to Subroutines: sub_11D9E2 sub_11DA6C sub_11DAC6 sub_11DACE sub_11DB6A sub_11DB84 sub_11DC70
Subroutine sub_11D8BE Refers to Scalars: $13C306 $13C308
Subroutine sub_11D9E2 Refers to Scalars: $13C306
Subroutine sub_11DA6C Refers to Scalars: $13C306
Subroutine sub_11DACE Refers to Scalars: $13C306 $13C306 $13C306 $13C306
Subroutine sub_11DB84 Refers to Subroutines: sub_1158F6 sub_115C4E sub_115D2C
Subroutine sub_11DB84 Refers to Tables: 93
Subroutine sub_11DC70 Refers to Subroutines: sub_11D8BE sub_11DCD4 sub_11DD4A sub_11DD78 sub_11DDB2 sub_1255A6
Subroutine sub_11DCD4 Refers to Subroutines: sub_11DC70
Subroutine sub_11DCD4 Refers to Scalars: $13C312 $13C314 $13C318 $13C31A $13C316
Subroutine sub_11DD4A Refers to Subroutines: sub_115D2C sub_11DC70
Subroutine sub_11DD4A Refers to Tables: 95 94
Subroutine sub_11DD78 Refers to Subroutines: sub_115C4E sub_11DC70
Subroutine sub_11DDB2 Refers to Subroutines: sub_11DC70
Subroutine sub_11DE04 Refers to Subroutines: sub_1255A6
Subroutine sub_11DE04 Refers to Scalars: $13C31C $13C31E
Subroutine sub_11DE4A Refers to Subroutines: sub_11E26A sub_11E280 sub_11E288 sub_11E2EE sub_11F68E
Subroutine sub_11DE4A Refers to Scalars: $13C34E
Subroutine sub_11E03E Refers to Subroutines: sub_115D2C sub_11E400 sub_11F68E
Subroutine sub_11E03E Refers to Tables: 17
Subroutine sub_11E03E Refers to Scalars: $13C338 $13C33A $13C33C $13C33E $13C326 $13C324 $13C32A $13C328 $13C32E $13C32C $13C330 $13C332 $13C326 $13C32E $13C330 $13C334
Subroutine sub_11E216 Refers to Subroutines: sub_11F68E
Subroutine sub_11E216 Refers to Scalars: $13C32A $13C334 $13C328
Subroutine sub_11E26A Refers to Scalars: $13C0C8
Subroutine sub_11E288 Refers to Subroutines: sub_115D2C
Subroutine sub_11E288 Refers to Tables: 100 110 109
Subroutine sub_11E288 Refers to Scalars: $13C0D0 $13C322
Subroutine sub_11E2EE Refers to Subroutines: sub_115D2C
Subroutine sub_11E2EE Refers to Tables: 99 110 109
Subroutine sub_11E2EE Refers to Scalars: $13C0D0 $13C320
Subroutine sub_11E36E Refers to Subroutines: sub_115D2C sub_11F68E
Subroutine sub_11E36E Refers to Tables: 96 97 98
Subroutine sub_11E36E Refers to Scalars: $13C336
Subroutine sub_11E400 Refers to Subroutines: sub_11E03E
Subroutine sub_11E400 Refers to Scalars: $13C340 $13C342 $13C346 $13C344 $13C34C $13C348 $13C34A
Subroutine sub_11E4BC Refers to Subroutines: sub_11E62C sub_11E640 sub_11E654 sub_11E65C sub_11E6CC sub_11E72E sub_11F68E sub_11FA40
Subroutine sub_11E62C Refers to Subroutines: sub_115D2C
Subroutine sub_11E62C Refers to Tables: 18
Subroutine sub_11E640 Refers to Subroutines: sub_115D2C
Subroutine sub_11E640 Refers to Tables: 19
Subroutine sub_11E65C Refers to Subroutines: sub_115D2C
Subroutine sub_11E65C Refers to Tables: 20 110 109
Subroutine sub_11E65C Refers to Scalars: $13C0D0 $13C350
Subroutine sub_11E6CC Refers to Subroutines: sub_115D2C
Subroutine sub_11E6CC Refers to Tables: 21 110 109
Subroutine sub_11E6CC Refers to Scalars: $13C0D0 $13C352
Subroutine sub_11E72E Refers to Scalars: $13C0C8
Subroutine sub_11E744 Refers to Subroutines: sub_1204C2
Subroutine sub_11E744 Refers to Scalars: $13C356 $13C354
Subroutine sub_11E7B8 Refers to Subroutines: sub_1204C2
Subroutine sub_11E7F8 Refers to Subroutines: sub_1204C2
Subroutine sub_11E7F8 Refers to Scalars: $13C358
Subroutine sub_11E894 Refers to Subroutines: sub_11E8A2 sub_11EA4C sub_11EA68 sub_11F68E
Subroutine sub_11E8A2 Refers to Subroutines: sub_11E894
Subroutine sub_11E8A2 Refers to Scalars: $13C35A $13C35E $13C35C $13C35E $13C35C
Subroutine sub_11EA4C Refers to Subroutines: sub_115D2C sub_11E894
Subroutine sub_11EA4C Refers to Tables: 22
Subroutine sub_11EA68 Refers to Subroutines: sub_115D2C sub_11E894
Subroutine sub_11EA68 Refers to Tables: 24 23 25
Subroutine sub_11EAB0 Refers to Subroutines: sub_11EBE4 sub_11EBF2 sub_11EC48 sub_11F68E
Subroutine sub_11EAB0 Refers to Scalars: $13C36A $13C364 $13C366 $13C36C
Subroutine sub_11EBD0 Refers to Subroutines: sub_110A60
Subroutine sub_11EBF2 Refers to Subroutines: sub_115D2C
Subroutine sub_11EBF2 Refers to Tables: 26
Subroutine sub_11EBF2 Refers to Scalars: $13C368 $13C0D0 $13C360
Subroutine sub_11EC48 Refers to Subroutines: sub_115D2C
Subroutine sub_11EC48 Refers to Tables: 27
Subroutine sub_11EC48 Refers to Scalars: $13C0D0 $13C362
Subroutine sub_11EC9C Refers to Subroutines: sub_115D2C
Subroutine sub_11EC9C Refers to Tables: 101 102 103 28 109
Subroutine sub_11EC9C Refers to Scalars: $13C370 $13C36E $13C3F4 $13C3F4 $13C3F6 $13C372 $13C374
Subroutine sub_11EDFE Refers to Subroutines: sub_11EF5C sub_11EF80 sub_11EFF6 sub_11FBD4 sub_11FDE2 sub_120AEC
Subroutine sub_11EDFE Refers to Scalars: $13C37A $13C378
Subroutine sub_11EF5C Refers to Scalars: $13C37C $13C37E
Subroutine sub_11EF80 Refers to Subroutines: sub_11EDFE
Subroutine sub_11EF80 Refers to Scalars: $13C374 $13C376 $13C380
Subroutine sub_11EFF6 Refers to Subroutines: sub_11EDFE
Subroutine sub_11EFF6 Refers to Scalars: $13C380 $13C37E $13C37C
Subroutine sub_11F026 Refers to Subroutines: sub_11F034 sub_11F204 sub_11F2BE
Subroutine sub_11F034 Refers to Subroutines: sub_11F026 sub_11F1D6 sub_11F1DE sub_11F236 sub_11F258 sub_11F298
Subroutine sub_11F034 Refers to Scalars: $13C388 $13C386 $13C388 $13C38A $13C388 $13C38A $13C388
Subroutine sub_11F1D6 Refers to Scalars: $13C40E
Subroutine sub_11F1DE Refers to Scalars: $13C38C
Subroutine sub_11F204 Refers to Subroutines: sub_11F026
Subroutine sub_11F204 Refers to Scalars: $13C392 $13C394
Subroutine sub_11F236 Refers to Scalars: $13C38C
Subroutine sub_11F258 Refers to Scalars: $13C38C
Subroutine sub_11F298 Refers to Scalars: $13C40E $13C38E $13C390 $13C38C
Subroutine sub_11F2BE Refers to Subroutines: sub_11F026
Subroutine sub_11F2BE Refers to Scalars: $13C384
Subroutine sub_11F322 Refers to Subroutines: sub_11F4FE sub_11F534 sub_11F556 sub_11FDE2
Subroutine sub_11F322 Refers to Scalars: $13C3A4 $13C3A2 $13C3A6 $13C3A0 $13C3A2 $13C3A0 $13C3A4 $13C3A6 $13C3A2 $13C3A0 $13C3A2 $13C3A4 $13C3A6
Subroutine sub_11F4FE Refers to Subroutines: sub_11F322
Subroutine sub_11F4FE Refers to Scalars: $13C3AA
Subroutine sub_11F534 Refers to Subroutines: sub_115D2C sub_11F322
Subroutine sub_11F534 Refers to Tables: 29
Subroutine sub_11F534 Refers to Scalars: $13C0D0
Subroutine sub_11F556 Refers to Subroutines: sub_11533E
Subroutine sub_11F556 Refers to Scalars: $13C3A8
Subroutine sub_11F56C Refers to Subroutines: sub_11F572 sub_1204C2
Subroutine sub_11F572 Refers to Subroutines: sub_11F56C sub_11F67A
Subroutine sub_11F572 Refers to Scalars: $13C3AE
Subroutine sub_11F67A Refers to Subroutines: sub_115D2C
Subroutine sub_11F67A Refers to Tables: 30
Subroutine sub_11F68E Refers to Subroutines: sub_11DE4A sub_11E03E sub_11E216 sub_11E36E sub_11E4BC sub_11E894 sub_11EAB0 sub_11F6EE sub_11F858 sub_11F8FC sub_11F960 sub_11F98A sub_11FAB8 sub_11FB1C sub_11FDE2
Subroutine sub_11F68E Refers to Scalars: $13C3D4
Subroutine sub_11F6EE Refers to Subroutines: sub_11F68E sub_11F9EE sub_11F9F6
Subroutine sub_11F6EE Refers to Scalars: $13C3D0 $13C3D2 $13C3D0
Subroutine sub_11F858 Refers to Subroutines: sub_11F68E
Subroutine sub_11F858 Refers to Scalars: $13C3C6 $13C3C4
Subroutine sub_11F8FC Refers to Subroutines: sub_115D2C sub_11F68E
Subroutine sub_11F8FC Refers to Tables: 33
Subroutine sub_11F8FC Refers to Scalars: $13C3BE
Subroutine sub_11F960 Refers to Subroutines: sub_11F68E
Subroutine sub_11F98A Refers to Subroutines: sub_11F68E
Subroutine sub_11F98A Refers to Scalars: $13C3BA $13C3B8 $13C3BC
Subroutine sub_11F9F6 Refers to Subroutines: sub_115D2C
Subroutine sub_11F9F6 Refers to Tables: 32
Subroutine sub_11F9F6 Refers to Scalars: $13C3C2 $13C3C0
Subroutine sub_11FA40 Refers to Scalars: $13C0D0
Subroutine sub_11FAB8 Refers to Subroutines: sub_11F68E
Subroutine sub_11FAB8 Refers to Scalars: $13C3C8 $13C3CA
Subroutine sub_11FAD0 Refers to Scalars: $13C3CC
Subroutine sub_11FAE2 Refers to Subroutines: sub_115D2C
Subroutine sub_11FAE2 Refers to Tables: 34
Subroutine sub_11FAE2 Refers to Scalars: $13C3CE
Subroutine sub_11FB1C Refers to Subroutines: sub_11F68E sub_11FAD0 sub_11FAE2 sub_11FB14
Subroutine sub_11FB1C Refers to Scalars: $13C3CC
Subroutine sub_11FBD4 Refers to Subroutines: sub_115C30
Subroutine sub_11FBD4 Refers to Scalars: $13C3D8 $13C3D6 $13C3DA
Subroutine sub_11FC2C Refers to Subroutines: sub_11FDA6 sub_11FDCC sub_11FDD4 sub_11FDE2
Subroutine sub_11FC2C Refers to Scalars: $13C3E0
Subroutine sub_11FDA6 Refers to Scalars: $13C3DE $13C3DC $13C3DC
Subroutine sub_11FDD4 Refers to Scalars: $13C3DC
Subroutine sub_11FDE2 Refers to Subroutines: sub_11EDFE sub_11F322 sub_11F68E sub_11FC2C sub_11FE20 sub_11FF08 sub_11FF10 sub_11FF6C sub_1200A0 sub_1200AE sub_1200BC sub_12071C sub_1255A6
Subroutine sub_11FE20 Refers to Subroutines: sub_11FDE2
Subroutine sub_11FE20 Refers to Scalars: $13C3F0 $13C3F0 $13C3F2 $13C3F8 $13C3F0 $13C3F2
Subroutine sub_11FF08 Refers to Subroutines: sub_11FDE2
Subroutine sub_11FF10 Refers to Subroutines: sub_115D2C sub_11FDE2
Subroutine sub_11FF10 Refers to Tables: 104 105
Subroutine sub_11FF6C Refers to Subroutines: sub_105B46 sub_1149A4 sub_115D2C sub_11FDE2
Subroutine sub_11FF6C Refers to Tables: 107 108 106 109
Subroutine sub_11FF6C Refers to Scalars: $13C3F4 $13C3F4 $13C3F6 $13C3E4 $13C3E6 $13C3E8 $13C3EA $13C3EC $13C3EE
Subroutine sub_1200A0 Refers to Subroutines: sub_11FDE2
Subroutine sub_1200A0 Refers to Scalars: $13C3E2
Subroutine sub_1200AE Refers to Subroutines: sub_11FDE2
Subroutine sub_1200BC Refers to Subroutines: sub_11FDE2 sub_1200CE sub_1201C6 sub_12032A sub_1204A4
Subroutine sub_1200CE Refers to Subroutines: sub_1200BC sub_1203B0 sub_1203C4 sub_120438 sub_120486 sub_12049A
Subroutine sub_1200CE Refers to Scalars: $13C3FA
Subroutine sub_1201C6 Refers to Subroutines: sub_1200BC sub_12037E sub_1203A8
Subroutine sub_1201C6 Refers to Scalars: $13C3FE
Subroutine sub_12032A Refers to Subroutines: sub_115D2C sub_1200BC
Subroutine sub_12032A Refers to Tables: 111 109
Subroutine sub_12032A Refers to Scalars: $13C40A $13C3FC
Subroutine sub_12037E Refers to Subroutines: sub_115C30
Subroutine sub_12037E Refers to Scalars: $13C400
Subroutine sub_1203B0 Refers to Scalars: $13C404
Subroutine sub_1203C4 Refers to Scalars: $13C406 $13C408 $13C402
Subroutine sub_120438 Refers to Subroutines: sub_115D2C
Subroutine sub_120438 Refers to Tables: 35
Subroutine sub_120438 Refers to Scalars: $13C36E
Subroutine sub_120486 Refers to Subroutines: sub_115D2C
Subroutine sub_120486 Refers to Tables: 36
Subroutine sub_1204A4 Refers to Subroutines: sub_115D2C sub_1200BC
Subroutine sub_1204A4 Refers to Tables: 37
Subroutine sub_1204C2 Refers to Subroutines: sub_11E744 sub_11E7B8 sub_11E7F8 sub_11F56C sub_1204E4 sub_120702
Subroutine sub_1204E4 Refers to Subroutines: sub_11E88C sub_11EC9C sub_11F026 sub_1204C2 sub_12064C sub_12067E sub_12068C sub_1206B8 sub_1206DC sub_1206E4 sub_1206FC
Subroutine sub_12064C Refers to Scalars: $13C412
Subroutine sub_12068C Refers to Subroutines: sub_115D2C
Subroutine sub_12068C Refers to Tables: 38
Subroutine sub_12068C Refers to Scalars: $13C40C $13C0C8 $13C0C8
Subroutine sub_1206B8 Refers to Subroutines: sub_115D2C
Subroutine sub_1206B8 Refers to Tables: 38
Subroutine sub_1206B8 Refers to Scalars: $13C0C8 $13C0C8
Subroutine sub_1206DC Refers to Scalars: $13C40E
Subroutine sub_1206E4 Refers to Subroutines: sub_115D2C
Subroutine sub_1206E4 Refers to Tables: 112
Subroutine sub_120702 Refers to Subroutines: sub_1204C2
Subroutine sub_120702 Refers to Scalars: $13C410
Subroutine sub_12071C Refers to Subroutines: sub_11FDE2 sub_1204C2 sub_120966 sub_1209CE sub_1209D6 sub_1209E4 sub_120A02 sub_120ABA sub_120AD4
Subroutine sub_12071C Refers to Scalars: $13C418 $13C414
Subroutine sub_120966 Refers to Subroutines: sub_115D2C sub_118CEE
Subroutine sub_120966 Refers to Tables: 113 109
Subroutine sub_120966 Refers to Scalars: $13C41A $13C0C8
Subroutine sub_1209CE Refers to Scalars: $13C40E
Subroutine sub_1209D6 Refers to Subroutines: sub_118CEE
Subroutine sub_1209E4 Refers to Subroutines: sub_118CEE
Subroutine sub_1209E4 Refers to Scalars: $13C416
Subroutine sub_120A02 Refers to Subroutines: sub_118CEE
Subroutine sub_120A02 Refers to Scalars: $13C0C8
Subroutine sub_120ABA Refers to Subroutines: sub_118CEE
Subroutine sub_120AD4 Refers to Subroutines: sub_115D2C
Subroutine sub_120AD4 Refers to Tables: 114
Subroutine sub_120AEC Refers to Subroutines: sub_11EDFE sub_120BB2 sub_120BDC sub_120BEA sub_120BFE
Subroutine sub_120AEC Refers to Scalars: $13C420
Subroutine sub_120BB2 Refers to Subroutines: sub_115C30
Subroutine sub_120BB2 Refers to Scalars: $13C3D6
Subroutine sub_120BDC Refers to Scalars: $13C41E
Subroutine sub_120BEA Refers to Scalars: $13C41C
Subroutine sub_120BFE Refers to Subroutines: sub_120AEC
Subroutine sub_120BFE Refers to Scalars: $13C41C
Subroutine sub_120C12 Refers to Subroutines: sub_120C40 sub_120C58 sub_120C72 sub_121070 sub_12110C sub_12115C sub_121652 sub_121748 sub_1219E4 sub_1255A6
Subroutine sub_120C40 Refers to Subroutines: sub_115D2C sub_120C12
Subroutine sub_120C40 Refers to Tables: 116
Subroutine sub_120C58 Refers to Subroutines: sub_120C12
Subroutine sub_120C58 Refers to Scalars: $13C432
Subroutine sub_120C72 Refers to Subroutines: sub_120C12 sub_120EC2 sub_120EDA sub_120F24 sub_120F50 sub_120F68 sub_120F7A sub_121028 sub_12104C
Subroutine sub_120C72 Refers to Scalars: $13C42E $13C42E $13C430 $13C430 $13C42E $13C42E $13C430 $13C430 $13C42E
Subroutine sub_120EC2 Refers to Subroutines: sub_115D2C
Subroutine sub_120EC2 Refers to Tables: 40
Subroutine sub_120EDA Refers to Subroutines: sub_115D2C
Subroutine sub_120EDA Refers to Tables: 115
Subroutine sub_120EDA Refers to Scalars: $13C42C $13C42A
Subroutine sub_120F24 Refers to Scalars: $13C430 $13C42E
Subroutine sub_120F7A Refers to Scalars: $13C426 $13C428 $13C426 $13C428 $13C426 $13C428 $13C426 $13C428
Subroutine sub_121028 Refers to Scalars: $13C430 $13C42E
Subroutine sub_12104C Refers to Scalars: $13C42E $13C430
Subroutine sub_121070 Refers to Subroutines: sub_114FDC sub_115D2C sub_120C12
Subroutine sub_121070 Refers to Tables: 39
Subroutine sub_121070 Refers to Scalars: $13C022
Subroutine sub_12110C Refers to Subroutines: sub_115D2C sub_120C12
Subroutine sub_12110C Refers to Tables: 117
Subroutine sub_12110C Refers to Scalars: $13C422 $13C422 $13C424
Subroutine sub_12115C Refers to Subroutines: sub_120C12 sub_12139C sub_1213A2 sub_1213A8 sub_1213BC sub_1213F4 sub_1213FC sub_12140E
Subroutine sub_12115C Refers to Scalars: $13C43A $13C438 $13C434 $13C434 $13C436 $13C436
Subroutine sub_1213A8 Refers to Subroutines: sub_115D2C
Subroutine sub_1213A8 Refers to Tables: 41
Subroutine sub_1213BC Refers to Subroutines: sub_115D2C
Subroutine sub_1213BC Refers to Tables: 119 118
Subroutine sub_1213FC Refers to Scalars: $13C434
Subroutine sub_12140E Refers to Scalars: $13C436
Subroutine sub_121420 Refers to Subroutines: sub_110A60 sub_114E08 sub_115D2C sub_1195C0 sub_11963C
Subroutine sub_121420 Refers to Tables: 129
Subroutine sub_1215D6 Refers to Subroutines: sub_1255A6
Subroutine sub_121652 Refers to Subroutines: sub_115C30 sub_115D2C sub_120C12
Subroutine sub_121652 Refers to Tables: 120 121
Subroutine sub_121652 Refers to Scalars: $13C440 $13C43E $13C43E $13C442
Subroutine sub_121748 Refers to Subroutines: sub_120C12 sub_121752 sub_1217B2
Subroutine sub_121752 Refers to Subroutines: sub_115D2C sub_121748
Subroutine sub_121752 Refers to Tables: 122 123 124
Subroutine sub_1217B2 Refers to Subroutines: sub_121748 sub_121854 sub_121874 sub_1219B6
Subroutine sub_1217B2 Refers to Scalars: $13C444
Subroutine sub_121874 Refers to Subroutines: sub_1219B6 sub_1219BC
Subroutine sub_121874 Refers to Scalars: $13C446 $13C446 $13C448 $13C446 $13C446 $13C446
Subroutine sub_1219BC Refers to Scalars: $13C448 $13C448
Subroutine sub_1219E4 Refers to Subroutines: sub_115D2C sub_120C12 sub_121B48 sub_121BCA sub_121BEE sub_121BF6 sub_121C0E sub_121C32 sub_121C66
Subroutine sub_1219E4 Refers to Tables: 42
Subroutine sub_1219E4 Refers to Scalars: $13C44E $13C44E $13C44A $13C44E
Subroutine sub_121B48 Refers to Subroutines: sub_115D2C
Subroutine sub_121B48 Refers to Tables: 125 126
Subroutine sub_121BCA Refers to Scalars: $13C44A $13C44A
Subroutine sub_121BF6 Refers to Subroutines: sub_115D2C
Subroutine sub_121BF6 Refers to Tables: 127
Subroutine sub_121C0E Refers to Subroutines: sub_115D2C
Subroutine sub_121C0E Refers to Tables: 128
Subroutine sub_121C32 Refers to Subroutines: sub_1219E4
Subroutine sub_121C32 Refers to Scalars: $13C44C
Subroutine sub_121C66 Refers to Subroutines: sub_1219E4
Subroutine sub_121C66 Refers to Scalars: $13C450
Subroutine sub_121CB8 Refers to Subroutines: sub_121D02 sub_1235D8 sub_123A28
Subroutine sub_121CCA Refers to Subroutines: sub_1235D8 sub_123A28 sub_125030 sub_1254EE
Subroutine sub_121D02 Refers to Subroutines: sub_121CB8
Subroutine sub_1220E2 Refers to Subroutines: sub_1142E8 sub_1143D8 sub_114B2C sub_114BC6 sub_122C94 sub_122CE8 sub_122D78 sub_122DDC sub_122F18 sub_12314C sub_1231B0 sub_1248A8 sub_1248DE sub_13483C
Subroutine sub_122C94 Refers to Subroutines: sub_1220E2 sub_12314C sub_1231B0
Subroutine sub_122CE8 Refers to Subroutines: sub_1220E2 sub_12314C
Subroutine sub_122D78 Refers to Subroutines: sub_1220E2 sub_12314C
Subroutine sub_122DDC Refers to Subroutines: sub_1220E2 sub_12314C
Subroutine sub_122F18 Refers to Subroutines: sub_1220E2
Subroutine sub_12314C Refers to Subroutines: sub_1220E2
Subroutine sub_1231B0 Refers to Subroutines: sub_11433C sub_1220E2 sub_122C94 sub_122CE8 sub_12314C sub_13483C
Subroutine sub_1232D8 Refers to Subroutines: sub_114784 sub_1147B2 sub_1236DA sub_125018 sub_125020 sub_125028
Subroutine sub_1235D8 Refers to Subroutines: sub_121CB8 sub_121CCA sub_1352E8 sub_1352FA
Subroutine sub_1235D8 Refers to Scalars: $13C452 $13C452
Subroutine sub_1236DA Refers to Subroutines: sub_1232D8 sub_1237E4 sub_123814 sub_12382E sub_13483C
Subroutine sub_1237E4 Refers to Subroutines: sub_1236DA
Subroutine sub_123814 Refers to Subroutines: sub_1236DA
Subroutine sub_12382E Refers to Subroutines: sub_1236DA
Subroutine sub_123A28 Refers to Subroutines: sub_121CB8 sub_121CCA sub_12404A sub_12541A sub_125460
Subroutine sub_123A28 Refers to Scalars: $13C454
Subroutine sub_123C86 Refers to Scalars: $13C1F0 $13CA9A $13CA9B
Subroutine sub_12404A Refers to Subroutines: sub_1166D4 sub_121F1A sub_1220E2 sub_1232D8 sub_124672 sub_12541A sub_125460 sub_125560
Subroutine sub_12404A Refers to Scalars: $13C456 $13C456 $13C456 $13C456 $13C456 $13C456
Subroutine sub_1246C8 Refers to Subroutines: sub_114C24 sub_11798A sub_1248A8 sub_12D51C
Subroutine sub_1248A8 Refers to Subroutines: sub_1220E2 sub_1246C8
Subroutine sub_1248DE Refers to Subroutines: sub_1220E2
Subroutine sub_1248DE Refers to Scalars: $13C3D4
Subroutine sub_125008 Refers to Subroutines: sub_118CEE sub_1352FA
Subroutine sub_125018 Refers to Subroutines: sub_1232D8
Subroutine sub_125020 Refers to Subroutines: sub_1232D8
Subroutine sub_125028 Refers to Subroutines: sub_1232D8
Subroutine sub_125030 Refers to Subroutines: sub_1119EE sub_121CCA sub_125044 sub_1251F8
Subroutine sub_125044 Refers to Subroutines: sub_125030 sub_12549A sub_1254A4 sub_1254DE
Subroutine sub_125044 Refers to Scalars: $13C458 $13C458 $13C458 $13C458 $13C458 $13C458
Subroutine sub_1251F8 Refers to Subroutines: sub_125030 sub_12549A sub_1254A4
Subroutine sub_1251F8 Refers to Scalars: $13C458 $13C458 $13C458 $13C458 $13C458 $13C458 $13C458
Subroutine sub_12541A Refers to Subroutines: sub_12549A
Subroutine sub_125460 Refers to Subroutines: sub_125472
Subroutine sub_125472 Refers to Subroutines: sub_125460 sub_12549A
Subroutine sub_1254EE Refers to Subroutines: sub_1119EE sub_121CCA
Subroutine sub_125560 Refers to Subroutines: sub_12558C
Subroutine sub_12558C Refers to Subroutines: sub_125560
Subroutine sub_1255A6 Refers to Subroutines: sub_119D6C sub_11A896 sub_11AB38 sub_11ADF2 sub_11AEEE sub_11B0EE sub_11B33A sub_11CD5C sub_11DC70 sub_11DE04 sub_11FDE2 sub_120C12 sub_1215D6 sub_1256DE sub_1258D8 sub_125C22 sub_128D9A sub_128EAC sub_128EBE sub_12A384 sub_12B7DE sub_12BA34 sub_12C01E sub_12C61E sub_12DD54 sub_12DFC2 sub_12E54C sub_12ED20 sub_12F00E sub_12F810 sub_12F9AC sub_130052 sub_132548 sub_132A68 sub_132C8A
Subroutine sub_1256DE Refers to Subroutines: sub_1255A6
Subroutine sub_1256DE Refers to Scalars: $13C476 $13C47C $13C47A $13C47A $13C474 $13C474 $13C476 $13C478 $13C47A
Subroutine sub_1258D8 Refers to Subroutines: sub_1255A6
Subroutine sub_1258D8 Refers to Scalars: $13C206
Subroutine sub_12593C Refers to Subroutines: sub_125946 sub_125AE8 sub_125C22
Subroutine sub_125946 Refers to Subroutines: sub_12593C sub_125C0E
Subroutine sub_125946 Refers to Scalars: $13C492 $13C484 $13C492 $13C492 $13C492 $13C492 $13C492
Subroutine sub_125AE8 Refers to Subroutines: sub_12593C
Subroutine sub_125AE8 Refers to Scalars: $13C47E $13C480 $13C47E $13C482
Subroutine sub_125C22 Refers to Subroutines: sub_1255A6 sub_12593C sub_125C3C sub_125D16 sub_125E46 sub_125E7E
Subroutine sub_125C3C Refers to Subroutines: sub_125C22 sub_125E16
Subroutine sub_125C3C Refers to Scalars: $13C48E $13C48C $13C48E
Subroutine sub_125D16 Refers to Subroutines: sub_125C22 sub_125E28
Subroutine sub_125D16 Refers to Scalars: $13C48A $13C486 $13C490 $13C488 $13C48A $13C490 $13C486 $13C488
Subroutine sub_125E16 Refers to Scalars: $13C48E
Subroutine sub_125E46 Refers to Subroutines: sub_125C22
Subroutine sub_125E7E Refers to Subroutines: sub_125C22 sub_125E94 sub_125F80 sub_1260F0 sub_1260FE sub_126150
Subroutine sub_125E94 Refers to Subroutines: sub_125E7E
Subroutine sub_125E94 Refers to Scalars: $13C494 $13C496 $13C496 $13C494
Subroutine sub_125F80 Refers to Subroutines: sub_125E7E sub_126118 sub_126126
Subroutine sub_125F80 Refers to Scalars: $13C49C $13C49E $13C498 $13C49E $13C49A
Subroutine sub_1260F0 Refers to Subroutines: sub_125E7E
Subroutine sub_1260FE Refers to Subroutines: sub_125E7E
Subroutine sub_1260FE Refers to Scalars: $13C4A4 $13C4A2 $13C4A4
Subroutine sub_126126 Refers to Subroutines: sub_115C30
Subroutine sub_126126 Refers to Scalars: $13C4A0
Subroutine sub_126150 Refers to Subroutines: sub_125E7E
Subroutine sub_126150 Refers to Scalars: $13C492
Subroutine sub_1261C8 Refers to Subroutines: sub_126204 sub_12622C sub_1264B6 sub_1265DC sub_12665C sub_1268DE sub_126CA4
Subroutine sub_126204 Refers to Subroutines: sub_1261C8
Subroutine sub_126204 Refers to Scalars: $13C4AC
Subroutine sub_12622C Refers to Subroutines: sub_1261C8 sub_1263F4 sub_126486 sub_12660A
Subroutine sub_12622C Refers to Scalars: $13C4A6 $13C4A6 $13C4A6 $13C4A6
Subroutine sub_126394 Refers to Subroutines: sub_115D2C
Subroutine sub_126394 Refers to Tables: 132 133
Subroutine sub_126394 Refers to Scalars: $13C4A8
Subroutine sub_1263F4 Refers to Subroutines: sub_115C30 sub_115D2C
Subroutine sub_1263F4 Refers to Tables: 130 131 45
Subroutine sub_1263F4 Refers to Scalars: $13C4AA
Subroutine sub_126486 Refers to Scalars: $13C4AC
Subroutine sub_1264B6 Refers to Subroutines: sub_1261C8 sub_126394 sub_12658A
Subroutine sub_12658A Refers to Subroutines: sub_115D2C
Subroutine sub_12658A Refers to Tables: 43 44
Subroutine sub_1265DC Refers to Subroutines: sub_1261C8
Subroutine sub_12665C Refers to Subroutines: sub_1261C8 sub_126684 sub_12676A sub_126808
Subroutine sub_126684 Refers to Subroutines: sub_12665C sub_1267A2
Subroutine sub_126684 Refers to Scalars: $13C4B0 $13C4AE
Subroutine sub_12676A Refers to Subroutines: sub_12665C
Subroutine sub_1267A2 Refers to Subroutines: sub_115C30
Subroutine sub_1267A2 Refers to Scalars: $13C4B2
Subroutine sub_126808 Refers to Subroutines: sub_12665C sub_1268B8
Subroutine sub_126808 Refers to Scalars: $13C4B4
Subroutine sub_1268DE Refers to Subroutines: sub_1261C8 sub_126924 sub_12697E sub_126A4A sub_126B12 sub_126C44
Subroutine sub_126924 Refers to Subroutines: sub_1268DE
Subroutine sub_12697E Refers to Subroutines: sub_1268DE
Subroutine sub_126A4A Refers to Subroutines: sub_1268DE
Subroutine sub_126B12 Refers to Subroutines: sub_1268DE
Subroutine sub_126B12 Refers to Scalars: $13C4B6 $13C4B8 $13C4B6
Subroutine sub_126C44 Refers to Subroutines: sub_1268DE
Subroutine sub_126CA4 Refers to Subroutines: sub_1261C8 sub_126CC0 sub_126D02
Subroutine sub_126CC0 Refers to Subroutines: sub_126CA4
Subroutine sub_126CC0 Refers to Scalars: $13C4BA $13C4BC $13C4C0 $13C4BE
Subroutine sub_126D02 Refers to Subroutines: sub_126CA4 sub_127010 sub_127032
Subroutine sub_126D02 Refers to Scalars: $13C4C2 $13C4C2 $13C4C4
Subroutine sub_127054 Refers to Subroutines: sub_128D9A
Subroutine sub_127054 Refers to Scalars: $13C4C6 $13C4C8
Subroutine sub_12718A Refers to Subroutines: sub_128D9A
Subroutine sub_12718A Refers to Scalars: $13C4CA
Subroutine sub_1271F2 Refers to Subroutines: sub_127258 sub_128D9A
Subroutine sub_12726C Refers to Subroutines: sub_127572 sub_127772 sub_128EAC
Subroutine sub_12726C Refers to Scalars: $13C51C $13C4CC $13C128 $13C4CE $13C4D2 $13C4D0
Subroutine sub_127572 Refers to Scalars: $13C51C $13C51C $13C520 $13C522 $13C524 $13C526 $13C528 $13C52C $13C52E $13C532 $13C534 $13C526 $13C52A $13C528 $13C52A $13C52C $13C530 $13C52E $13C530 $13C532 $13C536 $13C534 $13C536
Subroutine sub_127772 Refers to Scalars: $13C542 $13C4D4 $13C4D4
Subroutine sub_1277A4 Refers to Subroutines: sub_1277B6 sub_1277C6 sub_127820 sub_1279C2 sub_128D9A
Subroutine sub_1277B6 Refers to Subroutines: sub_1277A4
Subroutine sub_1277C6 Refers to Subroutines: sub_1277A4 sub_127A20 sub_127A54
Subroutine sub_127820 Refers to Subroutines: sub_115D2C sub_1277A4
Subroutine sub_127820 Refers to Tables: 134
Subroutine sub_1279C2 Refers to Subroutines: sub_1277A4
Subroutine sub_1279C2 Refers to Scalars: $13C4D8 $13C4DA
Subroutine sub_127A20 Refers to Subroutines: sub_115D2C
Subroutine sub_127A20 Refers to Tables: 47
Subroutine sub_127A20 Refers to Scalars: $13C4D6
Subroutine sub_127A54 Refers to Subroutines: sub_115D2C
Subroutine sub_127A54 Refers to Tables: 46
Subroutine sub_127A76 Refers to Subroutines: sub_127B08 sub_128D9A
Subroutine sub_127A76 Refers to Scalars: $13C4DC
Subroutine sub_127B2C Refers to Subroutines: sub_127D06 sub_127DD6 sub_127FD0 sub_128D9A
Subroutine sub_127B2C Refers to Scalars: $13C4E2 $13C4EE
Subroutine sub_127D06 Refers to Subroutines: sub_127D6E sub_127D88 sub_127DBE
Subroutine sub_127DBE Refers to Scalars: $13C4E8
Subroutine sub_127DD6 Refers to Subroutines: sub_127E7C sub_127E94 sub_127F34
Subroutine sub_127DD6 Refers to Scalars: $13C4EC
Subroutine sub_127E94 Refers to Scalars: $13C4E0 $13C4EA $13C4E6 $13C4E0 $13C4EA
Subroutine sub_127F34 Refers to Scalars: $13C4DE $13C4E4 $13C4DE
Subroutine sub_127FD0 Refers to Subroutines: sub_127B2C
Subroutine sub_127FEE Refers to Subroutines: sub_128086 sub_128D9A
Subroutine sub_127FEE Refers to Scalars: $13C4F0 $13C4F0
Subroutine sub_128110 Refers to Subroutines: sub_128280 sub_1282BA sub_128D9A
Subroutine sub_128110 Refers to Scalars: $13C4F4 $13C4F6 $13C4F6
Subroutine sub_128280 Refers to Scalars: $13C4F2
Subroutine sub_1282BA Refers to Subroutines: sub_12838A
Subroutine sub_1282BA Refers to Scalars: $13C4FC
Subroutine sub_12838A Refers to Scalars: $13C4FA $13C4F8 $13C3DC
Subroutine sub_1283E0 Refers to Subroutines: sub_128488 sub_128D9A
Subroutine sub_1283E0 Refers to Scalars: $13C4FE $13C4FE
Subroutine sub_1284AC Refers to Subroutines: sub_1284C2 sub_12858E sub_128D9A
Subroutine sub_1284AC Refers to Scalars: $13C206
Subroutine sub_1284C2 Refers to Subroutines: sub_1284AC
Subroutine sub_1284C2 Refers to Scalars: $13C504 $13C502 $13C500 $13C502
Subroutine sub_12858E Refers to Subroutines: sub_1284AC
Subroutine sub_1285C4 Refers to Subroutines: sub_1285CE sub_1287FC sub_128D9A
Subroutine sub_1285CE Refers to Subroutines: sub_1285C4 sub_1287AE sub_1287BC
Subroutine sub_1285CE Refers to Scalars: $13C506 $13C508 $13C50A $13C506 $13C508 $13C50C $13C50E $13C510 $13C50C $13C50E
Subroutine sub_1287BC Refers to Scalars: $13C512
Subroutine sub_1287FC Refers to Subroutines: sub_1285C4
Subroutine sub_12881A Refers to Subroutines: sub_128828 sub_12885E sub_12890E sub_128D9A
Subroutine sub_128828 Refers to Subroutines: sub_12881A
Subroutine sub_128828 Refers to Scalars: $13C51A $13C518 $13C516
Subroutine sub_12885E Refers to Subroutines: sub_12881A
Subroutine sub_12885E Refers to Scalars: $13C514
Subroutine sub_12890E Refers to Subroutines: sub_12881A
Subroutine sub_12892C Refers to Subroutines: sub_12893C sub_1289F4 sub_128EAC sub_129B60
Subroutine sub_12893C Refers to Subroutines: sub_12892C
Subroutine sub_12893C Refers to Scalars: $13C51E $13C51E $13C51E
Subroutine sub_1289F4 Refers to Subroutines: sub_12892C
Subroutine sub_1289F4 Refers to Scalars: $13C51C $13C520 $13C522 $13C524 $13C526 $13C528 $13C52C $13C52E $13C532 $13C534 $13C526 $13C52A $13C528 $13C52A $13C52C $13C530 $13C52E $13C530 $13C532 $13C536 $13C534 $13C536
Subroutine sub_128BC8 Refers to Subroutines: sub_128D2C sub_128D3E sub_128D56 sub_128D82 sub_128EBE
Subroutine sub_128BC8 Refers to Scalars: $13C542 $13C542 $13C542 $13C542 $13C542
Subroutine sub_128D9A Refers to Subroutines: sub_1255A6 sub_127054 sub_12718A sub_1271F2 sub_1277A4 sub_127A76 sub_127B2C sub_127FEE sub_128110 sub_1283E0 sub_1284AC sub_1285C4 sub_12881A sub_128E08 sub_128E3A
Subroutine sub_128E08 Refers to Subroutines: sub_128D9A
Subroutine sub_128E3A Refers to Subroutines: sub_128D9A
Subroutine sub_128EAC Refers to Subroutines: sub_1255A6 sub_12726C sub_12892C sub_1292C4
Subroutine sub_128EBE Refers to Subroutines: sub_1255A6 sub_128BC8 sub_128ED0 sub_129754
Subroutine sub_128ED0 Refers to Subroutines: sub_128EBE sub_1292B6 sub_1292FE sub_129326 sub_129342 sub_129408 sub_12941C sub_129458 sub_129460 sub_12947E sub_1294BC sub_1294CC sub_1294D4 sub_1294DC sub_12986E sub_129A8A
Subroutine sub_128ED0 Refers to Scalars: $13C538 $13C53C $13C53E $13C53C $13C53E $13C540 $13C552 $13C53C
Subroutine sub_1292C4 Refers to Subroutines: sub_128EAC sub_129848
Subroutine sub_1292C4 Refers to Scalars: $13C53A
Subroutine sub_1292FE Refers to Scalars: $13C550
Subroutine sub_129326 Refers to Scalars: $13C544 $13C546
Subroutine sub_129342 Refers to Subroutines: sub_129444
Subroutine sub_12941C Refers to Scalars: $13C544 $13C54C $13C546 $13C54E
Subroutine sub_129444 Refers to Subroutines: sub_115D2C
Subroutine sub_129444 Refers to Tables: 48
Subroutine sub_129460 Refers to Scalars: $13C542 $13C548 $13C54A
Subroutine sub_12947E Refers to Subroutines: sub_115D2C
Subroutine sub_12947E Refers to Tables: 49
Subroutine sub_1294DC Refers to Scalars: $13C542
Subroutine sub_129514 Refers to Subroutines: sub_1295EA sub_1295FE sub_129636 sub_129662
Subroutine sub_129514 Refers to Scalars: $13C554 $13C554 $13C554
Subroutine sub_1295FE Refers to Subroutines: sub_115D2C sub_129848
Subroutine sub_1295FE Refers to Tables: 50
Subroutine sub_129662 Refers to Subroutines: sub_129514 sub_129722 sub_129748
Subroutine sub_129662 Refers to Scalars: $13C558 $13C558 $13C556 $13C558 $13C556 $13C558
Subroutine sub_129722 Refers to Subroutines: sub_129848
Subroutine sub_129722 Refers to Scalars: $13C55A
Subroutine sub_129754 Refers to Subroutines: sub_128EBE sub_12980C sub_129818 sub_12983C
Subroutine sub_129818 Refers to Subroutines: sub_129848
Subroutine sub_129818 Refers to Scalars: $13C55C
Subroutine sub_129848 Refers to Subroutines: sub_1292C4 sub_1295FE
Subroutine sub_12986E Refers to Subroutines: sub_129A98 sub_129AA6 sub_129AB4 sub_129AFA sub_129B44 sub_129B52
Subroutine sub_12986E Refers to Scalars: $13C542 $13C562 $13C562 $13C542 $13C542 $13C562 $13C542 $13C562
Subroutine sub_129A98 Refers to Scalars: $13C560
Subroutine sub_129AA6 Refers to Scalars: $13C560
Subroutine sub_129AB4 Refers to Subroutines: sub_115D2C
Subroutine sub_129AB4 Refers to Tables: 89
Subroutine sub_129AB4 Refers to Scalars: $13C546
Subroutine sub_129AFA Refers to Subroutines: sub_115D2C
Subroutine sub_129AFA Refers to Tables: 90
Subroutine sub_129AFA Refers to Scalars: $13C546
Subroutine sub_129B44 Refers to Scalars: $13C55E
Subroutine sub_129B52 Refers to Scalars: $13C55E
Subroutine sub_129B60 Refers to Subroutines: sub_12892C sub_129C10 sub_129C34 sub_129C46 sub_129C58 sub_129CB4 sub_129CFE
Subroutine sub_129B60 Refers to Scalars: $13C564 $13C564 $13C564
Subroutine sub_129C10 Refers to Scalars: $13C566 $13C568
Subroutine sub_129C46 Refers to Subroutines: sub_129B60
Subroutine sub_129C58 Refers to Subroutines: sub_115D2C
Subroutine sub_129C58 Refers to Tables: 135 51 52
Subroutine sub_129CB4 Refers to Subroutines: sub_115D2C
Subroutine sub_129CB4 Refers to Tables: 53 54
Subroutine sub_129CB4 Refers to Scalars: $13C56A
Subroutine sub_129CFE Refers to Subroutines: sub_129848
Subroutine sub_129D24 Refers to Subroutines: sub_110A60 sub_115D2C sub_129FCE sub_12A034 sub_12A2FA
Subroutine sub_129D24 Refers to Tables: 55 56 57
Subroutine sub_129D24 Refers to Scalars: $13C572
Subroutine sub_129FCE Refers to Subroutines: sub_129D24
Subroutine sub_129FCE Refers to Scalars: $13C56C $13C56E
Subroutine sub_12A034 Refers to Subroutines: sub_129D24
Subroutine sub_12A034 Refers to Scalars: $13C570 $13C570
Subroutine sub_12A2FA Refers to Subroutines: sub_129D24
Subroutine sub_12A35E Refers to Subroutines: sub_110A60 sub_110CDE
Subroutine sub_12A384 Refers to Subroutines: sub_1255A6 sub_12A3EC sub_12A464
Subroutine sub_12A3EC Refers to Subroutines: sub_12A5AE sub_12A6A6
Subroutine sub_12A3EC Refers to Scalars: $13C584
Subroutine sub_12A464 Refers to Subroutines: sub_12A6CA sub_12A7E0 sub_12A804 sub_12A834 sub_12A850 sub_12A882
Subroutine sub_12A464 Refers to Scalars: $13C582 $13C582 $13C582 $13C582 $13C582 $13C584
Subroutine sub_12A5AE Refers to Scalars: $13C576 $13C574 $13C584
Subroutine sub_12A6CA Refers to Scalars: $13C578 $13C57A $13C584
Subroutine sub_12A850 Refers to Scalars: $13C56C $13C56E $13C57E $13C57C $13C56C $13C56E $13C57E $13C57C
Subroutine sub_12A8F4 Refers to Subroutines: sub_110A60 sub_12AA10 sub_12AA72 sub_12AC2A sub_12AC84
Subroutine sub_12AA72 Refers to Subroutines: sub_115D2C
Subroutine sub_12AA72 Refers to Tables: 136 58
Subroutine sub_12AA72 Refers to Scalars: $13CA9C
Subroutine sub_12AC54 Refers to Subroutines: sub_110A60
Subroutine sub_12AC84 Refers to Subroutines: sub_12AC9C sub_12AEF8
Subroutine sub_12AC84 Refers to Scalars: $13CA9E
Subroutine sub_12AC9C Refers to Subroutines: sub_12AC84 sub_12AD22 sub_12AE08 sub_12AE8E
Subroutine sub_12AC9C Refers to Scalars: $13C58C $13CA9D $13C588 $13C58A $13C586
Subroutine sub_12AD22 Refers to Subroutines: sub_12AC9C
Subroutine sub_12AE08 Refers to Subroutines: sub_12AC9C
Subroutine sub_12AE08 Refers to Scalars: $13C58E
Subroutine sub_12AE8E Refers to Subroutines: sub_12AC9C
Subroutine sub_12AE8E Refers to Scalars: $13C590
Subroutine sub_12AEF8 Refers to Subroutines: sub_12AC84 sub_12DA76
Subroutine sub_12AEF8 Refers to Scalars: $13C58E $13C590
Subroutine sub_12AF48 Refers to Subroutines: sub_110A60 sub_12B018 sub_12B18C sub_12B408
Subroutine sub_12B018 Refers to Subroutines: sub_115D2C
Subroutine sub_12B018 Refers to Tables: 137 59
Subroutine sub_12B018 Refers to Scalars: $13CAA0 $13CA9F
Subroutine sub_12B18C Refers to Subroutines: sub_12B1E4 sub_12B214 sub_12B25A sub_12B27E sub_12B2F6
Subroutine sub_12B214 Refers to Subroutines: sub_115D2C
Subroutine sub_12B214 Refers to Tables: 138
Subroutine sub_12B27E Refers to Subroutines: sub_115D2C
Subroutine sub_12B27E Refers to Tables: 139
Subroutine sub_12B27E Refers to Scalars: $13C596 $13C592
Subroutine sub_12B2F6 Refers to Scalars: $13C12C $13C594
Subroutine sub_12B328 Refers to Subroutines: sub_110A60
Subroutine sub_12B330 Refers to Subroutines: sub_110A60
Subroutine sub_12B330 Refers to Scalars: $13C598 $13C59A
Subroutine sub_12B408 Refers to Subroutines: sub_12B420 sub_12B460 sub_12B492
Subroutine sub_12B420 Refers to Subroutines: sub_12B408 sub_12B4C4 sub_12B4F6
Subroutine sub_12B460 Refers to Subroutines: sub_12B408
Subroutine sub_12B492 Refers to Subroutines: sub_12B408
Subroutine sub_12B4F6 Refers to Scalars: $13C56C $13C56E $13C57E $13C57C $13C59A $13C598 $13C57E $13C57C
Subroutine sub_12B528 Refers to Subroutines: sub_12B532 sub_12B5F0 sub_12BA34
Subroutine sub_12B532 Refers to Subroutines: sub_12B528
Subroutine sub_12B532 Refers to Scalars: $13C5A0 $13C5A0 $13C5A0
Subroutine sub_12B5F0 Refers to Subroutines: sub_12B528
Subroutine sub_12B5F0 Refers to Scalars: $13C59E $13C5B8 $13C5A2 $13C5B4 $13C5B6 $13C5A8 $13C5AA $13C5A4 $13C5AC $13C5AE $13C5B0 $13C5B2 $13C5A6
Subroutine sub_12B7DE Refers to Subroutines: sub_1255A6 sub_12B8D4 sub_12B8E8 sub_12B8FC
Subroutine sub_12B7DE Refers to Scalars: $13C5BA $13C5BC $13C5BA $13C5BC $13C5BC
Subroutine sub_12B8D4 Refers to Subroutines: sub_115D2C
Subroutine sub_12B8D4 Refers to Tables: 60
Subroutine sub_12B8E8 Refers to Subroutines: sub_115D2C
Subroutine sub_12B8E8 Refers to Tables: 61
Subroutine sub_12B8FC Refers to Scalars: $13C5BC
Subroutine sub_12B904 Refers to Subroutines: sub_12B920 sub_12B9C6 sub_12BA34
Subroutine sub_12B920 Refers to Subroutines: sub_12B904
Subroutine sub_12B9C6 Refers to Subroutines: sub_12B904
Subroutine sub_12B9C6 Refers to Scalars: $13C5BE $13C5C0
Subroutine sub_12BA34 Refers to Subroutines: sub_1255A6 sub_12B528 sub_12B904 sub_12BB18 sub_12BB2A sub_12BB50 sub_12BB58 sub_12BB64
Subroutine sub_12BB2A Refers to Scalars: $13C5C2
Subroutine sub_12BB64 Refers to Subroutines: sub_12BCFA sub_12BD1E sub_12BD2C sub_12BD60 sub_12BD86
Subroutine sub_12BB64 Refers to Scalars: $13C5CA $13C5C4 $13C5C4 $13C5C4 $13C5C8 $13C5C6 $13C5C4 $13C5C4
Subroutine sub_12BCFA Refers to Scalars: $13C5CC $13C5CE
Subroutine sub_12BD2C Refers to Subroutines: sub_115D2C
Subroutine sub_12BD2C Refers to Tables: 140
Subroutine sub_12BD86 Refers to Scalars: $13C5C6
Subroutine sub_12BDDE Refers to Subroutines: sub_12BDEC sub_12BEA2 sub_12BFE4 sub_12C01E
Subroutine sub_12BDEC Refers to Subroutines: sub_12BDDE
Subroutine sub_12BDEC Refers to Scalars: $13C5D0 $13C5D2 $13C5D0 $13C5D0
Subroutine sub_12BEA2 Refers to Subroutines: sub_12BDDE
Subroutine sub_12BEA2 Refers to Scalars: $13C5D6 $13C5D8 $13C5DA $13C5DC $13C5D4 $13C5DE
Subroutine sub_12BFE4 Refers to Subroutines: sub_12BDDE sub_12BFF2
Subroutine sub_12BFF2 Refers to Subroutines: sub_12BFE4
Subroutine sub_12BFF2 Refers to Scalars: $13C5E0
Subroutine sub_12C01E Refers to Subroutines: sub_1255A6 sub_12BDDE sub_12C030 sub_12C346
Subroutine sub_12C030 Refers to Subroutines: sub_12C01E sub_12C11A sub_12C128 sub_12C136 sub_12C1CE sub_12C214
Subroutine sub_12C030 Refers to Scalars: $13C5E2
Subroutine sub_12C136 Refers to Scalars: $13C5E6 $13C5E8 $13C5EC $13C5EE
Subroutine sub_12C1CE Refers to Subroutines: sub_129848
Subroutine sub_12C1CE Refers to Scalars: $13C5F2 $13C5F4 $13C5F4 $13C5F6 $13C5F6
Subroutine sub_12C214 Refers to Subroutines: sub_115D2C
Subroutine sub_12C214 Refers to Tables: 62
Subroutine sub_12C214 Refers to Scalars: $13C5F0 $13C5EA $13C5E4
Subroutine sub_12C242 Refers to Subroutines: sub_12C2C4 sub_12C2D8 sub_12C2FE
Subroutine sub_12C242 Refers to Scalars: $13C5F8 $13C5F8 $13C5F8
Subroutine sub_12C2D8 Refers to Subroutines: sub_129848
Subroutine sub_12C2D8 Refers to Scalars: $13C5FA
Subroutine sub_12C2FE Refers to Subroutines: sub_115D2C sub_129848
Subroutine sub_12C2FE Refers to Tables: 63
Subroutine sub_12C346 Refers to Subroutines: sub_12C01E sub_12C35A sub_12C414 sub_12C4CE
Subroutine sub_12C35A Refers to Subroutines: sub_12C346
Subroutine sub_12C35A Refers to Scalars: $13C8A2 $13C8A4 $13C8A2 $13C5FC $13C8A4 $13C5FC
Subroutine sub_12C414 Refers to Subroutines: sub_12C346
Subroutine sub_12C414 Refers to Scalars: $13C8A6 $13C8A8 $13C8A6 $13C5FE $13C8A8 $13C5FE
Subroutine sub_12C4CE Refers to Subroutines: sub_12C346
Subroutine sub_12C4E2 Refers to Subroutines: sub_12C61E
Subroutine sub_12C4E2 Refers to Scalars: $13C604 $13C602 $13C604 $13C602 $13C130
Subroutine sub_12C57E Refers to Subroutines: sub_12C5C2
Subroutine sub_12C5C2 Refers to Subroutines: sub_12C57E sub_12C8BA sub_12C8F4
Subroutine sub_12C5C2 Refers to Scalars: $13C600
Subroutine sub_12C61E Refers to Subroutines: sub_1255A6 sub_12C4E2 sub_12C87E sub_12C8A4
Subroutine sub_12C87E Refers to Scalars: $13C606
Subroutine sub_12C8BA Refers to Subroutines: sub_115C30 sub_12C5C2
Subroutine sub_12C8BA Refers to Scalars: $13C608
Subroutine sub_12C8F4 Refers to Subroutines: sub_115D2C sub_12C5C2
Subroutine sub_12C8F4 Refers to Tables: 64
Subroutine sub_12C926 Refers to Subroutines: sub_12CA22 sub_12CB06 sub_12CD0E sub_12D324 sub_12D452 sub_12D580 sub_12D5EE sub_12D8B2 sub_12DAA0 sub_12DD1C
Subroutine sub_12CA22 Refers to Subroutines: sub_12C926 sub_12CB6A sub_12D1E2 sub_12DA76
Subroutine sub_12CA22 Refers to Scalars: $13C612
Subroutine sub_12CB06 Refers to Subroutines: sub_12C926 sub_12CB6A
Subroutine sub_12CC06 Refers to Subroutines: sub_12CFAE
Subroutine sub_12CD0E Refers to Subroutines: sub_12C926 sub_12CDD6 sub_12CE8E sub_12CFAE
Subroutine sub_12CDD6 Refers to Subroutines: sub_12CD0E
Subroutine sub_12CE8E Refers to Subroutines: sub_12CD0E
Subroutine sub_12CFAE Refers to Subroutines: sub_12CC06 sub_12CD0E sub_12D136
Subroutine sub_12D136 Refers to Subroutines: sub_12CFAE
Subroutine sub_12D324 Refers to Subroutines: sub_12C926
Subroutine sub_12D452 Refers to Subroutines: sub_12C926 sub_12D4B4 sub_12D51C
Subroutine sub_12D51C Refers to Subroutines: sub_1246C8
Subroutine sub_12D580 Refers to Subroutines: sub_12C926
Subroutine sub_12D580 Refers to Scalars: $13C610 $13C610
Subroutine sub_12D5EE Refers to Subroutines: sub_12C926
Subroutine sub_12D5EE Refers to Scalars: $13C60E $13C610 $13C610 $13C610
Subroutine sub_12D8B2 Refers to Subroutines: sub_12C926 sub_12D8F4 sub_12D9BE
Subroutine sub_12D9BE Refers to Subroutines: sub_12DA4E sub_12DA56
Subroutine sub_12DA56 Refers to Scalars: $13C616 $13C614
Subroutine sub_12DA76 Refers to Subroutines: sub_12AEF8
Subroutine sub_12DAA0 Refers to Subroutines: sub_12C926
Subroutine sub_12DD1C Refers to Subroutines: sub_12C926
Subroutine sub_12DD1C Refers to Scalars: $13C17A $13C134
Subroutine sub_12DD54 Refers to Subroutines: sub_1255A6 sub_12DD72 sub_12DF9E
Subroutine sub_12DD72 Refers to Subroutines: sub_12DD54
Subroutine sub_12DF9E Refers to Subroutines: sub_12DD54
Subroutine sub_12DFC2 Refers to Subroutines: sub_1255A6 sub_12DFD8 sub_12E0BE sub_12E20E sub_12E336 sub_12E3FE
Subroutine sub_12DFD8 Refers to Subroutines: sub_12DFC2
Subroutine sub_12DFD8 Refers to Scalars: $13C62C $13C61A $13C618
Subroutine sub_12E0BE Refers to Subroutines: sub_12DFC2 sub_12E4D4
Subroutine sub_12E0BE Refers to Scalars: $13C62A
Subroutine sub_12E20E Refers to Subroutines: sub_12DFC2 sub_12E446 sub_12E49A
Subroutine sub_12E20E Refers to Scalars: $13C622 $13C626 $13C624
Subroutine sub_12E336 Refers to Subroutines: sub_12DFC2 sub_12E47E
Subroutine sub_12E336 Refers to Scalars: $13C620 $13C61E $13C620 $13C626
Subroutine sub_12E3FE Refers to Subroutines: sub_115D2C sub_12DFC2
Subroutine sub_12E3FE Refers to Tables: 65
Subroutine sub_12E3FE Refers to Scalars: $13C630 $13C632 $13C628
Subroutine sub_12E446 Refers to Scalars: $13C61C $13C624
Subroutine sub_12E47E Refers to Scalars: $13C620 $13C61E
Subroutine sub_12E49A Refers to Scalars: $13C622 $13C624
Subroutine sub_12E4D4 Refers to Subroutines: sub_115D2C
Subroutine sub_12E4D4 Refers to Tables: 141
Subroutine sub_12E4EC Refers to Subroutines: sub_110A60
Subroutine sub_12E4EC Refers to Scalars: $13C62E
Subroutine sub_12E54C Refers to Subroutines: sub_1255A6 sub_12E5BE sub_12E5D2 sub_12E634 sub_12E81E sub_12E874 sub_12E88E sub_12E8A2 sub_12E950 sub_12E9AA sub_12E9D0 sub_12E9F6 sub_12EA42 sub_12EA72 sub_12EAB6 sub_12EB78 sub_12EB98 sub_12EC30 sub_12ECFE
Subroutine sub_12E5BE Refers to Scalars: $13C648
Subroutine sub_12E634 Refers to Subroutines: sub_12E616
Subroutine sub_12E634 Refers to Scalars: $13C660 $13C656 $13C658 $13C65A $13C65C $13C65E
Subroutine sub_12E81E Refers to Scalars: $13C64A $13C648 $13C63A $13C634
Subroutine sub_12E88E Refers to Subroutines: sub_115D2C
Subroutine sub_12E88E Refers to Tables: 66
Subroutine sub_12E8A2 Refers to Scalars: $13C646 $13C63E $13C63C
Subroutine sub_12E950 Refers to Scalars: $13C638 $13C636 $13C638
Subroutine sub_12E9AA Refers to Scalars: $13C640
Subroutine sub_12E9F6 Refers to Scalars: $13C648 $13C642 $13C644 $13C634
Subroutine sub_12EA42 Refers to Scalars: $13C648 $13C648
Subroutine sub_12EAB6 Refers to Scalars: $13C2DA $13C652 $13C650
Subroutine sub_12EB78 Refers to Scalars: $13C64E $13C64C
Subroutine sub_12EB98 Refers to Subroutines: sub_11C914
Subroutine sub_12EC30 Refers to Subroutines: sub_12ECC6 sub_12ECF4
Subroutine sub_12ECC6 Refers to Scalars: $13C654
Subroutine sub_12ED20 Refers to Subroutines: sub_1255A6 sub_12ED32 sub_12EECA sub_12EF08 sub_12EF16
Subroutine sub_12ED32 Refers to Subroutines: sub_12ED20
Subroutine sub_12ED32 Refers to Scalars: $13C662 $13C664
Subroutine sub_12EECA Refers to Subroutines: sub_115D2C sub_12ED20
Subroutine sub_12EECA Refers to Tables: 143 142
Subroutine sub_12EECA Refers to Scalars: $13C666 $13C17A
Subroutine sub_12EF08 Refers to Subroutines: sub_12ED20
Subroutine sub_12EF16 Refers to Subroutines: sub_12ED20
Subroutine sub_12EF16 Refers to Scalars: $13C668 $13C66A $13C66C $13C66E $13C670 $13C668 $13C66A $13C66C $13C66E $13C668 $13C66A
Subroutine sub_12F00E Refers to Subroutines: sub_1255A6 sub_12F146 sub_12F184 sub_12F1D8 sub_12F206 sub_12F228
Subroutine sub_12F146 Refers to Subroutines: sub_11533E
Subroutine sub_12F146 Refers to Scalars: $13C676
Subroutine sub_12F184 Refers to Subroutines: sub_11533E
Subroutine sub_12F184 Refers to Scalars: $13C676 $13C676
Subroutine sub_12F1D8 Refers to Subroutines: sub_115D2C
Subroutine sub_12F1D8 Refers to Tables: 67
Subroutine sub_12F206 Refers to Scalars: $13C674
Subroutine sub_12F228 Refers to Scalars: $13C672
Subroutine sub_12F250 Refers to Subroutines: sub_12F25A sub_12F7DC
Subroutine sub_12F25A Refers to Subroutines: sub_12F250 sub_12F778 sub_12F784 sub_12F78A sub_12F7C4
Subroutine sub_12F25A Refers to Scalars: $13C67E
Subroutine sub_12F7DC Refers to Subroutines: sub_12F250
Subroutine sub_12F810 Refers to Subroutines: sub_1255A6 sub_12F816
Subroutine sub_12F816 Refers to Subroutines: sub_12F810 sub_12F89A sub_12F920 sub_12F95E
Subroutine sub_12F9AC Refers to Subroutines: sub_1255A6 sub_12F9BA sub_12FC06 sub_12FC28
Subroutine sub_12F9BA Refers to Subroutines: sub_12F9AC sub_12FB80 sub_12FBA8 sub_12FBB0 sub_12FBC0 sub_12FBF4
Subroutine sub_12FC06 Refers to Subroutines: sub_12F9AC
Subroutine sub_12FC06 Refers to Scalars: $13CAA4 $13CAA3
Subroutine sub_12FC28 Refers to Subroutines: sub_12F9AC
Subroutine sub_12FC92 Refers to Subroutines: sub_12FCA8 sub_12FE82 sub_12FF16 sub_12FFF8 sub_130012 sub_130052
Subroutine sub_12FCA8 Refers to Subroutines: sub_12FC92 sub_12FE68 sub_13137C
Subroutine sub_12FCA8 Refers to Scalars: $13C68C $13C680 $13C686 $13C688 $13C684 $13C680 $13C682 $13C684 $13C680 $13C682 $13C684 $13C680 $13C684 $13C680
Subroutine sub_12FE68 Refers to Scalars: $13C680 $13C688 $13C680
Subroutine sub_12FE82 Refers to Subroutines: sub_12FC92 sub_12FFA4 sub_12FFE8
Subroutine sub_12FE82 Refers to Scalars: $13C682
Subroutine sub_12FF16 Refers to Subroutines: sub_12FC92
Subroutine sub_12FF16 Refers to Scalars: $13C68A
Subroutine sub_12FFF8 Refers to Subroutines: sub_105B46 sub_1149A4 sub_115D2C sub_12FC92
Subroutine sub_12FFF8 Refers to Tables: 68
Subroutine sub_130012 Refers to Subroutines: sub_12FC92
Subroutine sub_130012 Refers to Scalars: $13CA5C
Subroutine sub_130052 Refers to Subroutines: sub_11521A sub_1255A6 sub_12FC92 sub_130084 sub_1300C6 sub_130176 sub_130188 sub_13027E sub_1303F8 sub_130486 sub_130E1E
Subroutine sub_130084 Refers to Subroutines: sub_130052
Subroutine sub_1300C6 Refers to Subroutines: sub_130052
Subroutine sub_1300C6 Refers to Scalars: $13C138 $13C69E
Subroutine sub_130176 Refers to Subroutines: sub_130052
Subroutine sub_130188 Refers to Subroutines: sub_115D2C sub_130052
Subroutine sub_130188 Refers to Tables: 144 145 146
Subroutine sub_130188 Refers to Scalars: $13C690 $13CAA5
Subroutine sub_13027E Refers to Subroutines: sub_130052 sub_1303D8 sub_1303E8 sub_1303F0
Subroutine sub_13027E Refers to Scalars: $13C692 $13C694 $13C698 $13C698 $13C69A $13C692 $13C694 $13C692 $13C694 $13C696
Subroutine sub_1303F8 Refers to Subroutines: sub_130052
Subroutine sub_1303F8 Refers to Scalars: $13C69C $13C69C
Subroutine sub_130486 Refers to Subroutines: sub_130052 sub_130494 sub_1304B4 sub_1306B0
Subroutine sub_130494 Refers to Subroutines: sub_130486
Subroutine sub_1304B4 Refers to Subroutines: sub_130486 sub_130612 sub_130662
Subroutine sub_1304B4 Refers to Scalars: $13C6A0 $13C6A2 $13C6A0 $13C6A0 $13C6A2
Subroutine sub_130612 Refers to Subroutines: sub_115D2C
Subroutine sub_130612 Refers to Tables: 69 70 71
Subroutine sub_130662 Refers to Scalars: $13C6A8 $13C6AA $13C6AC $13C6A4
Subroutine sub_1306B0 Refers to Subroutines: sub_130486
Subroutine sub_1306B0 Refers to Scalars: $13C6A6
Subroutine sub_1306CA Refers to Subroutines: sub_115D2C sub_1307FE sub_130834 sub_13083E
Subroutine sub_1306CA Refers to Tables: 72 73
Subroutine sub_1306CA Refers to Scalars: $13C6AE $13C6B0 $13C6B2
Subroutine sub_1307FE Refers to Scalars: $13C6B4
Subroutine sub_13089E Refers to Subroutines: sub_115D2C sub_1310F6
Subroutine sub_13089E Refers to Tables: 164 147 147
Subroutine sub_13089E Refers to Scalars: $13C6B6
Subroutine sub_130950 Refers to Subroutines: sub_130966 sub_130B82 sub_130BB2 sub_130BE0 sub_130CA6 sub_130FC4
Subroutine sub_130966 Refers to Subroutines: sub_130950 sub_130BF8 sub_130C00 sub_130C3A sub_130C5C
Subroutine sub_130966 Refers to Scalars: $13C6CE $13C6B8 $13C6BA $13C6CE $13C6B8 $13C6BA $13C6B8 $13C6CE $13C6B8 $13C6BA $13C6B8 $13C6BA
Subroutine sub_130B82 Refers to Subroutines: sub_115D2C sub_130950
Subroutine sub_130B82 Refers to Tables: 149
Subroutine sub_130B82 Refers to Scalars: $13C6CC $13C6CA
Subroutine sub_130BB2 Refers to Subroutines: sub_130950
Subroutine sub_130BB2 Refers to Scalars: $13C6C0
Subroutine sub_130BE0 Refers to Subroutines: sub_115D2C sub_130950
Subroutine sub_130BE0 Refers to Tables: 148
Subroutine sub_130C00 Refers to Scalars: $13C6CE $13C6D0 $13C6CE $13C6C2
Subroutine sub_130C3A Refers to Scalars: $13C6B8 $13C6BA
Subroutine sub_130C5C Refers to Scalars: $13C6BE $13C6BC $13C6BE $13C6BC $13C6B8 $13C6BA $13C6B8 $13C6BA $13C6BC $13C6B8 $13C6BA
Subroutine sub_130CA6 Refers to Subroutines: sub_130950 sub_130E0A sub_130E14
Subroutine sub_130CA6 Refers to Scalars: $13C6C6 $13C2E2 $13C6C4 $13C6C8 $13C6C6 $13C6C4 $13C6C6 $13C2E2 $13C6C4 $13C6C6 $13C2E2 $13C6C4
Subroutine sub_130E14 Refers to Scalars: $13C2E2
Subroutine sub_130E1E Refers to Subroutines: sub_130052 sub_1306CA sub_130FB6 sub_130FC4 sub_131024 sub_13135E
Subroutine sub_130F06 Refers to Subroutines: sub_130FC4 sub_131006 sub_13101E
Subroutine sub_130F06 Refers to Scalars: $13C6DE $13C6E4 $13C6E2 $13C6E0
Subroutine sub_130FB6 Refers to Subroutines: sub_130FBC
Subroutine sub_130FBC Refers to Subroutines: sub_130FB6
Subroutine sub_130FBC Refers to Scalars: $13C6D2
Subroutine sub_130FC4 Refers to Subroutines: sub_130950 sub_130F06 sub_130FD8 sub_1310DE
Subroutine sub_130FD8 Refers to Subroutines: sub_130FC4
Subroutine sub_130FD8 Refers to Scalars: $13C6E6 $13C2E2
Subroutine sub_131006 Refers to Subroutines: sub_115D2C
Subroutine sub_131006 Refers to Tables: 152
Subroutine sub_131024 Refers to Subroutines: sub_13104A sub_1310AE sub_1310C6 sub_1310F6 sub_1311E4 sub_1311F6 sub_13121E sub_131242 sub_13127E
Subroutine sub_13104A Refers to Subroutines: sub_115D2C sub_131024
Subroutine sub_13104A Refers to Tables: 151
Subroutine sub_13104A Refers to Scalars: $13C6DC $13C6DA $13C6DC $13C6DC $13C6DA
Subroutine sub_1310AE Refers to Subroutines: sub_115D2C sub_131024
Subroutine sub_1310AE Refers to Tables: 150
Subroutine sub_1310C6 Refers to Subroutines: sub_115D2C sub_131024
Subroutine sub_1310C6 Refers to Tables: 153
Subroutine sub_1310DE Refers to Subroutines: sub_115D2C sub_130FC4
Subroutine sub_1310DE Refers to Tables: 154
Subroutine sub_1310F6 Refers to Subroutines: sub_13089E sub_131024 sub_13110E sub_131126 sub_131154 sub_131198
Subroutine sub_13110E Refers to Subroutines: sub_115D2C sub_1310F6
Subroutine sub_13110E Refers to Tables: 155
Subroutine sub_131126 Refers to Subroutines: sub_115D2C sub_1310F6
Subroutine sub_131126 Refers to Tables: 156
Subroutine sub_131154 Refers to Subroutines: sub_115D2C sub_1310F6
Subroutine sub_131154 Refers to Tables: 157
Subroutine sub_131154 Refers to Scalars: $13C6D6 $13C17A $13C6D6
Subroutine sub_131198 Refers to Subroutines: sub_1310F6
Subroutine sub_131198 Refers to Scalars: $13C6D4
Subroutine sub_1311E4 Refers to Subroutines: sub_131024
Subroutine sub_1311E4 Refers to Scalars: $13C6E8
Subroutine sub_1311F6 Refers to Subroutines: sub_131024
Subroutine sub_1311F6 Refers to Scalars: $13C6D8
Subroutine sub_13121E Refers to Subroutines: sub_131024
Subroutine sub_131242 Refers to Subroutines: sub_131024
Subroutine sub_131242 Refers to Scalars: $13C62C $13C13C
Subroutine sub_13127E Refers to Subroutines: sub_131024
Subroutine sub_13135E Refers to Subroutines: sub_115D2C
Subroutine sub_13135E Refers to Tables: 73
Subroutine sub_13137C Refers to Subroutines: sub_115D2C
Subroutine sub_13137C Refers to Tables: 74
Subroutine sub_13137C Refers to Scalars: $13C6EA $13C6EA
Subroutine sub_1313AA Refers to Subroutines: sub_1314F2 sub_131532 sub_13159E sub_1315C4 sub_131AFC sub_131D54 sub_131F5E sub_13206E sub_13209A sub_132186 sub_1321A2
Subroutine sub_1315C4 Refers to Scalars: $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA $13C6EC $13C0FA
Subroutine sub_132204 Refers to Subroutines: sub_116ED0
Subroutine sub_132250 Refers to Subroutines: sub_1174D8
Subroutine sub_132548 Refers to Subroutines: sub_1255A6
Subroutine sub_132562 Refers to Subroutines: sub_115C30 sub_132A02
Subroutine sub_132562 Refers to Scalars: $13C6F4 $13C6F2 $13C62C
Subroutine sub_132710 Refers to Subroutines: sub_110A60 sub_1327A8 sub_1327B0 sub_132820
Subroutine sub_132710 Refers to Scalars: $13C6F6 $13C6F6 $13C6F6 $13C6F8
Subroutine sub_1327B0 Refers to Subroutines: sub_11533E
Subroutine sub_1327B0 Refers to Scalars: $13C6FA
Subroutine sub_132820 Refers to Subroutines: sub_115C30
Subroutine sub_132820 Refers to Scalars: $13C6FC
Subroutine sub_132854 Refers to Subroutines: sub_115D2C sub_132A68
Subroutine sub_132854 Refers to Tables: 78 79 75 76 77 163 159 160 161 162
Subroutine sub_132926 Refers to Subroutines: sub_132A10 sub_132A4C sub_132A54 sub_132A68
Subroutine sub_132926 Refers to Scalars: $13C700 $13C6FE $13C6FE
Subroutine sub_132A02 Refers to Subroutines: sub_110A60 sub_132562
Subroutine sub_132A68 Refers to Subroutines: sub_115D2C sub_1255A6 sub_132854 sub_132926
Subroutine sub_132A68 Refers to Tables: 80
Subroutine sub_132AA2 Refers to Subroutines: sub_132AA8
Subroutine sub_132AA8 Refers to Subroutines: sub_132AA2 sub_132C50 sub_132C5E
Subroutine sub_132AA8 Refers to Scalars: $13C714 $13C714 $13C714
Subroutine sub_132C50 Refers to Subroutines: sub_132AA8
Subroutine sub_132C5E Refers to Subroutines: sub_132AA8
Subroutine sub_132C8A Refers to Subroutines: sub_1255A6 sub_132C9C sub_132DB4 sub_132DCC sub_132EC6
Subroutine sub_132C9C Refers to Subroutines: sub_132C8A sub_132E3C sub_132E4A sub_132E8A sub_132E9E sub_132EB2
Subroutine sub_132DB4 Refers to Subroutines: sub_115D2C sub_132C8A
Subroutine sub_132DB4 Refers to Tables: 164
Subroutine sub_132DCC Refers to Subroutines: sub_132C8A
Subroutine sub_132E4A Refers to Scalars: $13C718
Subroutine sub_132E8A Refers to Subroutines: sub_115D2C
Subroutine sub_132E8A Refers to Tables: 81
Subroutine sub_132E9E Refers to Subroutines: sub_115D2C
Subroutine sub_132E9E Refers to Tables: 82
Subroutine sub_132EB2 Refers to Subroutines: sub_115D2C
Subroutine sub_132EB2 Refers to Tables: 83
Subroutine sub_132EC6 Refers to Subroutines: sub_1220E2 sub_1232D8 sub_123CF2 sub_132C8A sub_134700 sub_13471E sub_13473C sub_134758 sub_1347B4 sub_1347E8 sub_134816 sub_13482A
Subroutine sub_132EC6 Refers to Scalars: $13C716 $13C71A
Subroutine sub_134700 Refers to Subroutines: sub_13482A
Subroutine sub_13471E Refers to Subroutines: sub_13482A
Subroutine sub_13473C Refers to Subroutines: sub_13482A
Subroutine sub_13483C Refers to Subroutines: sub_113FFA sub_1146C4 sub_1158B0 sub_1195C0 sub_11963C sub_1220E2 sub_122C94 sub_122CE8 sub_12314C sub_1231B0
Subroutine sub_13483C Refers to Scalars: $13C45A $13C45E $13C460 $13C462 $13C464 $13C466 $13C2D8 $13C2D8 $13C466 $13C2DA $13C2DA $13C45C
Subroutine sub_1352FA Refers to Subroutines: sub_117890 sub_117E8A sub_118CEE sub_125008
Subroutine sub_1352FA Refers to Scalars: $13C25E $13C260
Subroutine sub_135582 Refers to Subroutines: sub_10494C sub_105B46 sub_1144F6 sub_1149A4 sub_1164BA
Subroutine sub_13A000 Refers to Subroutines: sub_100740 sub_100BF4 sub_1046C6 sub_10473E sub_104884 sub_1048BE sub_105C56 sub_105CCE sub_117F96 sub_130012

revilla · April 23, 2020

So this evening I've got a decent graphical explorer application wrapped around last night's disassembly parser. I've also added in support for RAM address variables too. So all set to go exploring. This is the tool (I'll include it in the set of freely downloadable MEMS3 tools):

You can use it to open up a dump in text file format from the disassembler. At the moment, I've had to do a couple of small changes to the disassembler dump to make it more friendly but I'll make the changes to the code so that it should be able to read the raw disassembly without any help, the idea being that I can the use the tool alongside the disassembler to guide me; and as I add more information in the disassembler as I unpick the ECU, I'll be able to reopen the disassembly in here and see all my changes (nice names for function and variables etc. to make it a lot easier to read).

There are two main tabs at the bottom for "Uses" and "Used By". You can explore the tree both ways.

In the "Uses" tab (show above) you can select a subroutine and see a tree of all the variables, scalars, tables and subroutines that it uses (and all the ones they use etc.). Nothing will appear in the tree twice, and everything is listed as being used by the shortest path from the the current subroutine, so it the current subroutine uses variable X and so does a subroutine used by a subroutine used by it, the variable X will always appear directly under the current subroutine.

In the "Used By" tab (shown below) you can select a variable, scalar, table or subroutine and see a tree of all the subroutines that use it (and all the subroutines that use them etc.). Same rules above on listing things through the shortest path to the item you are looking at.

If you double click in item in the tree view on either tab, it switches to the the other tab with that item selected, which makes it easy to walk up and down the tree, e.g. find a variable, find the subroutines that use it, then find all the variables that one of those subroutines uses etc.

And if you click on a subroutine anywhere, you see the full assembly language source code on the right.

So back to the original problem that I hit: I found a variable (word_134E) used by the routine that calculates the ignition timing (sub_120EDA) but I couldn't trace where that variable was being set. Can I answer the question with this tool now?

Here's the subroutine sub_120EDA, and it does list word_134E as a used variable.

So double-click that variable and here's a list of subroutines that reference it, including the original sub_120EDA but also sub_13484C which must be the one that sets it.

Double-click that subroutine and here's a source listing for it and a list of everything else it uses:

It looks long and complicated, but at least that's one more layer off the onion and I can keep going.

revilla · April 25, 2020

Today I have massively beefed up the tool I wrote above. It is now a full-blown code browser for the MEMS3 firmware code. It now reads the raw disassembler dump directly, and allows me to comment the code, rename functions, variables etc. within the tool. It also uses colour highlighting to format the code. Unlike the disassembler I was using, it understand higher-level concepts specific to MEMS3; for example it understands how to decode table lookups properly (these will actually be spread across multiple lines of code as it sets up the table offset and the axis values, then calls the common lookup function) so it can show references to specific tables in the code. Similarly it understands and recongnises how scalar values are access (using offsets against an address register a5 that always points to the start of the map) so it can show references to specific scalars. I think rather than working between this and the disassembler I can now work more easily just using this tool alone, and any features I find I need I can just add in.

Here is the main table lookup function in my tool:

And here I'm just starting to work through the ignition timing lookup:

You can see where this calls the Lookup_Table_Value subroutine above.

revilla · April 26, 2020

An interesting observation that confirms an earlier suspicion:

I knew that the program code in a MEMS3 consisted of a permanent, programmed-at-manufacture, non-rewriteable segment which contained what appeared to be a boot loader and a programmable segment which contained what appeared to be the main firmware. I had worked out that different boot loaders seemed to work happily with different firmware versions. But I was interested to know if the "boot loader" actually provided BIOS-like services to the main firmware, or whether the two were completely independent.

I've made my code browser classify subroutines according to which memory segment they are in. A "BootSubr" is in the boot loader code whereas a "Subroutine" is in the main firmware. I then wrote a few lines of code to identify where a Subroutine uses a BootSubr, or where a BootSubr refers to a Subroutine.

And the answer is; there are NO such calls made anywhere.

There is another mechanism whereby the firmware code could be leading to execution of boot loader code, as at the start of ROM there is a vector table which tells the processor what routines to execute when certain conditions occur (start up, errors, hardware and software interrupts etc.) and these point to boot loader code. However there is another vector table at the start of the firmware and it appears that when the boot loader switches into the firmware it updates the VBR (vector base register, which tells the processor where the vector table is) to point to this (which is what made me realise there were effectively two independent programs in the ROM in the first place) and so I think this closes that door too.

So the main firmware appears to completely independent of the boot loader code once it is running.

The "boot loader" appears to be just that; it's job is just to provide a mechanism for programming the firmware and to start the firmware at system boot up. As far as I can see it doesn't provide any kind of library of drivers for the hardware or anything like that.

This has two important implications:

It's good news for people upgrading firmwares and maps as it confirms what I've found; that there is very little chance of compatibility issues between different boot loaders and firmwares as they don't really interact.
The boot loader code cannot be influencing engine management. Once the ECU is running the engine management code in the main firmware it is no longer executing any boot loader code. So while the boot loader subroutines may be interesting, they are irrelevant for decoding the way engine management works. This eliminates about 25% of the code immediately.

JonT · April 27, 2020

re the case statements (#37), from some of the folk I've spoken to in the industry, empty conditions or functions is by design - the hooks are left so either during testing, or in different models of the same ECU they can insert additional functions. It also allows for MC/DC testing which might be needed for safety certification. Again, I've worked on safety software in the past where you'd still have a statement in what should be an unused condition to allow for testing.

If the higher level code was decently optimised, they wouldn't be able to do either of those. It's probably written in C and compiled, but with relatively low levels of optimisation, possibly with a bias to size rather than performance.

revilla · April 28, 2020

@JonT - You have BM.

revilla · April 30, 2020

I have to hold my hands up to a significant bug in the Mapper and Flasher applications.

I've realised that in later versions, if a Read is interrupted and you click Resume, the data read will be incomplete. Verify and Write were unaffected, but if you tried to write back a corrupted read it would cause problems.

The error was caused by an intermediate buffer I added to hold the data as it was being read so that I could write it back to the map with support for undo.

I've corrected the issue in a new release, version 4.64. I've updated all the download links with the corrected version.

revilla · May 1, 2020

I've spent the last few days "learning the ropes" with the MEMS3 programming. I've been starting to understand the way they did things and starting to recognise various data structures. I've been beefing up the capabilities of my code browser tool to get it to recognise all the different structures and approaches used. I think it's important for me to get the tool in good shape in order to be able to work my way through the code effectively.

I'm beginning to able to see the code as the original programmers would have seen it.

I've got it to decode all references to the tables and scalars I used in my model of the ECU for the MEMS3 Mapper project. It also understands in-RAM variables, custom register addresses for modules within the microcontroller, scalar arrays etc. It also now shares a definitions file with the MEMS3 Mapper application which means any tables or scalars defined in the mapper show up correctly here, and any tables I or scalars identify in here show up automatically in the mapper.

A few interesting observations so far:

Microcontroller Modules - The MC68336 microcontroller consists largely of a CPU32 code(beefed-up Motorola 68000 processor) with a lot of peripheral modules integrated. Each of these modules has a number of control registers. The bank of control registers can be mapped to different addresses. I've found that they are mapped to the very top of 32-bit address space in MEMS3 at addresses $FFFFF000 onwards. By reference to the MC68336 manual I've been able to identify the meanings of all the registers accessed by the code in this region. They seem to make sense, for example most of the modules are configured by the initial startup code of the firmware and the QADC module (quad analogue to digital converter) is used heavily by the routines that read the temperature sensors.
Tables - There is one single function used to access all tables in the map, both 2D and 3D. I've made my browser so that it lets you enter the name of the table lookup function at the top. Once you've found this, the code is automatically able to identify calls to this function as table lookups. They way the code is always structured, a few lines before this register d1 will be loaded with a constant. This turns out to be the offset to the table's address in the table index from the start of the map. So knowing that, my browser can show these as lookups into specific named tables which makes it a lot easier to follow what it is doing.
Scalars - The data I identified as scalar numbers in my MEMS3 Mapper application is always accessed in the same way in the code. There is an address register a5 which more or less permanently holds the address of the start of the map data ($13C000), and scalars for some reason are always looked up as offsets relative to that (I say "for some reason" as it implies that the map address could change, however the hardware arrangement of the EEPROM makes that unlikely as the map has to occupy a separately erasable segment, but maybe this was future-proofing in case future ECUs ever moved to a different larger EEPROM?). So the value of Scalar $13C100 will always be accessed in the code as $100(a5) and never as ($13C100). Sometimes scalars are addressed with a variable offset such as $100(a5,d2*2) which implies that the scalar at address $13C100 and those following it are actually an array (in this case the value of register d2 is the index into the array). I've made my code identify $nnn(a5) as a Scalar and $nnn(a5, as a ScalarArray.
Scalar Sizes - When I wrote my MEMS3 Mapper I made the assumption that the scalars were all 16-bit Word sized. This is the natural data size for the processor, and most of the scalars were round numbers when viewed as either signed or unsigned 16-bit words. Because of the way the 68000 processor family insists on alignment, this means that all scalars will have even-numbered addresses. Looking through the code, in just a few cases (about 15 out of several thousand) the code accesses a scalar using the above constructs at an odd address. Odd addresses can only ever be used for 8-bit Byte data.

This means that my original assumption is wrong - but only in a very small number of cases. To change the mapper to allow both word and byte scalar values would be a lot of work but it would also introduce a lot of unwanted complications, for example scalars at even addresses could be Word or Byte sized but scalars at odd addresses could only be Byte sized, and a Byte sized scalar may overlap the second byte of a Word type scalar sharing the same memory address.

For these reason I've decided that my model of scalar data will stay largely unchanged; scalars are defined as being 16-bit Word sized, but the code occasionally accesses the second byte of a scalar. I've made my browser decode even and odd scalar addresses differently. For example $100(a5) becomes (Scalar $13C000) in the listing, but $101(a5) becomes (Scalar $13C000+1). This means that the scalar definitions still synchronise correctly between the browser and mapper applications. If I ever do find that the two bytes of what for me is a single scalar are used for completely different purposes (unlikely I think) I will just have to name it "This | That" or similar.
Subroutines - As the boot loader occupies addresses $100000-$10FFFF and the firmware occupies addresses, $110000-$139FFF, and as I've proved that the boot loader and firmware are essentially independent, I've been able to classify subroutines as "Subroutine" or "BootSub" depending on whether they are part of the firmware or boot loader. Similarly I've classified memory variables as "BootVar" if they are solely referred to by the boot loader (variables aren't shared between the two anyway). I can largely ignore BootSub and BootVar for analysing engine management code.
Local Variables - In most programming languages your would use "local variables" a lot within subroutines. These are variables which exist only for the duration of the execution of that subroutine. They would normally be allocated on the stack (se even when nested, each executing copy of the subroutine has its own copies). The 68000 machine language has special instructions for this LINK and UNLK. LINK reserves space on the stack, UNLK releases it before returning. You can see these used here:

The bit I've highlighted declares constants for the variables which are offsets from the stack pointed, and LINK instruction reserves 24 bytes for the local variables.

The interesting thing is that this is the ONLY place in the whole code where genuine stack local variables are used. In every other case, the closest thing to a local variable is a memory variable which is only used by the one subroutine. I guess with only a limited amount of RAM available (4kB) a large variable sized stack may have been a luxury they couldn't afford. I still find it surprising because a "variable only used by one subroutine" is not really like a local variable in that if a subroutine is called recursively, all instances will share the same variable which will probably just cause problems, so I'm guessing that in most cases the code is written such that subroutines aren't called recursively; but in that case, using global variable addresses means that RAM is allocated for the variables of all subroutines at all times, even when not executing, so it still seems like a wasteful strategy. I guess at least it means that the maximum size of the stack can be strictly controlled. I'm more used to PC programming than tightly constrained embedded programming so this may all just be normal.

What it does mean though is that when a subroutine is called, its "local" variables will still hold the values they did when it last exited. So this allows data to persist between calls, which is very different to stack variables. This seems to be used in various places to implement "state machine" type arrangements, where a "local" variable holds a defined state code, say 0..5, and the behaviour of the subroutine both depends upon this state code and moves between different states when different criteria are met.

Here's an example. The code basically starts with what amounts to a CASE statement, branching off to different pieces of code depending on the value of the persistent state variable. At this point it hasn't calculated a value for this variable so it just contains the state from the last time the subroutine was called. The different code branches do different things, but also conditionally update the persistent state variable which will determine the route that execution takes the next time it is called.

In many cases theses "states" are numbered 0..5. There are also several tables in the map which have mysterious axis numbered 0..5 and these include once which is deeply involved with pop and crackle effects and which I want to understand properly:

I've wondered about all sorts of meanings for the numbers 0..5 in these tables, and from what I could gather they seemed to be some sort of sequence that it progressed through but I wasn't sure whether this was on a time basis or what. I now suspect that they will be the same "states" that I'm seeing in the code, so hopefully when I get to grips with this area of the code a bit more I'll understand what they are. They may be something as simple as "Cranking", "Post Start", "Warm Up", "Hot" ... I don't know yet, but I'm getting closer.

I've classified variables as either Variable or LocalVar depending upon whether they are accessed by multiple subroutines (in which they are more interesting as they pass data between subroutines) or just one subroutine (in which case they only need to be considered as part of the inner workings of that subroutine). These classifications will help be navigate and analyse the code later.
Main Calculation Runs - There appear to be a small number of master calculation run routines which are nothing but a sequential list of calls to other subroutines. Some of these in turn are just further sequential lists of calls to lower level subroutines. I suspect these are the main calculation runs which do a full run through calculating all the parameter and variables. As I start to unpick what the lower level table access routines are doing this should become clearer.

john milner · May 28, 2020

I have still not applied any changes but I am rereading the extensive notes in an attempt to pick out what is best for me.

The main two things that have been highlighted as a way to improve response are within the "Accel. Retard (...)" area. I have been trying to think of why would Rover have wanted a feature that reduced performance. It could be a way to reduce performance in a cooler engine and that the reduction is removed when hot. This would mean someone applying the "0" tune up would have a noticeably more responsive engine from start up but it would be the same as a regular tune when hot. Effectively this would mean that Rover created this as a way to protect a cold engine from some of the ill effects of being driven hard. The only other thing that I can think of is that it was created to somehow boost PAS for low speed manoeuvring.

I have read elsewhere that the VVC Inlet Cam Duration can in theory go between 220 & 295 degrees. 225 to 288 seems to be the range used possibly to have a safe margin of error. Solid cams could be where the averaging of VVC inlet duration idea came from as solid high performance cams would need to be somewhere near the middle but a variable mechanism has a range of settings so can go higher and lower. Some comments about not veering too far from standard and about VVC beating solid in this regard here - https://www.mg-rover.org/threads/vvc-high-lift-cams-not-solid-vvc.459823/

Are there any temporary tweaks (2500-3000rpm) that are likely to be useful at MOT time?

The Firmware ID table has six VVC firmwares listed. Each of the values against KSR3P006-8 are two or three points higher than the preceding firmwares. Are the higher values better? Does the firmware ID relate to the BHP variant, for example my firmware is KSR3SP002?

revilla · May 28, 2020

I think the acceleration retard effects were just to make it a bit smoother. We might want our little cars to jump if we boot them suddenly but the average mum on a school run may not. I think you might be expecting a bit too much ... these changes do add up and together make a noticeable difference but they're not going to radically change the car into a monster or anything. If you change something and you don't like it you can always change it back. I wouldn't go leaning off the mixture or advancing the ignition at random though, that's where you may do damage. But those "softening" effects are safe enough to play with.

The "average" idea on the VVC mechs was mine! Not to put too fine a point on it: I've seen what several remappers have done, I can't go around giving out their numbers but I can give you some hints in the right direction. And if you do that you'll be closer to what other people have done than you are now. That's all there is to it.

I think the VVC inlet duration is usually quoted as nominally 220°-290° but don't get hung up on a couple of degrees here and there on that, I've checked the timing with dial gauges on many VVC engines now and the accuracy of the stock timing is dreadful. By the time you get to the rear inlets with the accumulated errors you can easily see 17° retard vs. ideal, which is more than a whole tooth on the pulleys (15 crank degrees). When timing them with offset dowels it's not at all uncommon to find you actually have to slip the pulley by a tooth to get close enough to tweak on the dowels, then paint on new timing marks.

Those Mike Satur inlet cams never did have a very good reputation. They are reground from stock cams and they increase the lift quite a lot; this can only be done by grinding down the base circle which means the lifter oil feeds no longer align correctly. Ideally they need some fettling of the oil feed holes in the heads but they were still known to have problems. I think the valve acceleration and the loads placed on the VVC mechs were too great and led to failures. The standard VVC mechs have poor valve acceleration but Rover did that for a reason, it's all the mechs will take. That's why with a 290° full deployment duration and say a 270° inlet cam the peak performance is still down on equivalent solid cams. The wide duration tells you that the valves are off their seats for a long time but due to the poor acceleration they're not wide open for so long. It was really noticeable how much stronger Piper valve springs were when I was rebuilding a modified solid cam engine recently. They will cope with a much hotter profile but would totally overload then VVC drive system.

Those firmware version numbers just represent the continued development of the firmware over time I think. From what I'm seeing in the assembly language code there's a lot of processing of exceptions and special cases done in code rather than through tables. More so than I would expect in a generic programmable ECU as they are specifically coded to a particular application. So there will be a few new features and improvements in the later ones but they're not radically different. Most of the key tables are the same and you can happily copy table data between them. They certainly don't relate to the BHP variants; nearly all of those maps I've listed are nominally 160s.

Although there don't seem to be so many Caterham owners choosing to play with it so far, my posts have been picked up widely in the MG community and I'm getting a lot of emails from people who have been playing with it. I've got people who have modified their maps in France, Spain, Portugal, Netherlands, Germany, Greece, Philippines and Australia and I know of two garages who are now using it, one specialising in MGs and one using it on S1 Elise models. So far nobody has reported any major failures.

The two issues that have come up were 1) a problem reading the configuration file on non-English machines which meant the axis scales were displayed incorrectly and 2) an occasional issue found by a couple of people where it would reach 98.8% of the map write and then stop with what appeared to be a timeout from the ECU. It turned out the ECU wasn't able to handle the "speed" at which I was writing, my code was sending a transfer message as soon as it received the response to the previous message and this was hogging the CPU time on the ECU with real-time priority processing and not giving it a chance to keep up with housekeeping tasks. Both of these issues are now fixed, so do download the latest version.

In the case of the last issue all that was needed was a few milliseconds delay between messages to give the ECU chance to catch up. My "fail safe" writing algorithm did what it was supposed to do though and neither of the ECUs were bricked, both users were happily able to rewrite the map with the fixed version (actually they were able to rewrite them with the original version after switching to Rover BMW protocol as this doesn't implement timeouts, and only ISO14230-2 protocol was affected).

john milner · May 30, 2020

I did consider the mum going to the shops reason but thought as the retard was turned off when hot that it could be something else. Although that does fit with the idea of a car mainly being used for very short journeys.

Very surprised by the valve acceleration being an issue with VVC and I can see how that would reduce it's benefits and goes a long way to explaining why solid cams are somewhere in the middle ground but are still better. I always thought solid was mainly better for higher performance because they are stronger and can take more abuse. Although I still don't understand how averaging out the numbers can be better than having more variables that cover different scenarios. I guess that it comes down proof is in the pudding and if it works it means it works.

revilla · May 17, 2021

I was recently contacted by both Alan Bowler and Northampton Motorsport. Alan's car was at Northampton for a major engine rebuild. It was essentially a 1.8 SuperSport with Vernier-timed 633 cams and forged pistons. It was running standard MEMS3 engine management and was running very badly indeed; lambda value were as high as 1.3 in places and it was detonating badly in the mid-range.

Unfortunately they had bricked the original ECU (a long story, still not sure exactly what happened but with my latest release they would not be able to do it, and even if they did, it would be recoverable). So they used my MEMS3 Mapper to read the firmware and map from somebody else's SuperSport and emailed it me, and I flashed that onto a spare MG TF ECU that I had here.

I then took that ECU down to them and we spent a very interesting (and successful!) time in the afternoon using MEMS3 Mapper in anger on the rolling road. By the end of the session we had the engine absolutely singing. It was pulling cleanly to the rev limit with sensible fuelling across the range and no signs of detonation. It made healthy power and torque curves and came in just below his class limit. Alan has subsequently given the car a good shake-down on track and confirms that is performing nicely.

Alex and Troy were kind enough to take the time to explain to me exactly what they were doing and why, and we discussed what features I would need to add to the tool to make it into a truly useful rolling road mapping tool. Troy also demonstrated these features to me in the mapping tools for other ECUs so I could see how they usually worked. In the end it was only really a few user interface tools to allow manipulation of the numbers that were missing. On the day, we managed by copying and pasting some tables from the tool into Excel, modelling some of the numbers in Excel and then copying and pasting back again.

I've since spent some time implementing the suggested changes and making some further changes of my own. I have now updated the initial post on this thread with a write-up that is up to date with version 4.87. The download links provided like to the new version.

The most important changes in recent releases include:

Robust protection against bad reads or corrupted files to prevent them from subsequently being written to the ECU, with corrected checksums, risking bricking the ECU (this is what happened to Alan's original ECU, I had a look at the file that they were writing and the data in it was incomplete). It now always corrects checksums on write to the ECU and on save to disk. Before reading from ECU or disk, it invalidates each block by writing a flag into the last byte. If the read fails to complete, that flag is not overwritten and the block is left marked as invalid. If it ever finds an incorrect checksum after reading from ECU or disk, it regards the read as corrupted and immediately marks the block as invalid. It does not allow invalid blocks to be written to the ECU, even if the checksum is subsequently corrected.
Strong warnings to the user if they try to edit memory values directly in the hexadecimal tab, as the application cannot determine whether these edits are valid or not.
A new function to recover a bricked ECU. I posted about this feature today, here: https://www.lotus7.club/forum/techtalk/recovering-bricked-rover-mems3-ecu-without-opening-case. I'm really pleased with this - I'm confident that it will allow any ECU bricked by a bad firmware or map write (by my tool or any other programming tool) to be recovered easily, no matter how badly it has been messed up. No need to take anything apart, it's all done through the OBDII port in a few seconds.
Value menu added. This contains the mathematical manipulation tools requested by Northampton Motorsport. It contains options to increase or decrease the numbers in a range, or scale them up or down (by factors which can be configured for different data measures). It also allows one column or row to be copied across or down a range of cells. Finally it allow liner interpolation across or down a range of cells, keeping the edge cells fixed and interpolating the cells in between.
Support for writing full EEPROM-reader format files with a boot loader extracted from another file. A small number of sample boot loader files provided. This was found to be important because people are using my tool to map Land Rover Td5 diesel engines, which turn out to have a very closely related MEMS3-based ECU; however the diesel ECUs contain one of two possible high-side switch driver ICs and they identify which one they have from the NNN part number encoded into the boot loader, so it is critical to get the right boot loader (any petrol boot loader seems to work on any petrol ECU with any firmware and map). People are using my tool right across the MG, Rover and Land Rover communities now and I have had messages from people and garages using it right around the world.
Support for opening maps read using Galletto.
Many, many little tidy-ups and bug fixes.

I’m hopeful that some of the learnings from the bricked ECU recovery will help me get a bit deeper into disassembling the machine code inside the ECU. For example, having identified the OBDII port control registers I can now quite easily track down the OBDII routines and this may lead to me lists of supported commands and their routines. I have another mixed hardware / software project on the go which I hope will allow me to see in a lot more detail what the ECU is doing to the engine as I make map changes – that one has been ongoing for more than a year but all will be written up eventually. So hopefully there is still more to come in terms of understanding and manipulating MEMS3.

Mechanical Moz · May 18, 2021

That's awesome, great to see that it's being used with success by lots of folk.

Remapping the Rover MEMS3 ECU

Recommended Posts

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Posted Images

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Create an account or sign in to comment

Create an account

Sign in