Smart Unloading Train Stop

Smart Unloading Train Stop


Smart Unloading Train Stop image 1

Welcome, fellow engineers, to my guide of a smart unloading train station for vanilla factorio (0.14.x).

The goal of the train station is to determine which type of item a train has loaded, and unload it until a defined storage limit for this item type has been reached. This makes it possible to use a single train station for different products, and unload at max speed: all inserters - except 2 :( - are active at once.

Here is the basic conept I will use to realize the project.

Unload a single item to a steel chest to determine what the train has loaded. From now on known as 'identification item'. - I haven't been able to find any other way to get a train's content into the circuit network (without mods). Alpha 0.15 - scheduled for Feb 2017 I believe - will (hopefully) make this a lot easier.

Use this item so send a corresponding signal to filter inserters to unload - if the storage limit has not been reached.

Use timers to return the identification item back to the train - Reset station logic for the next train.

Send off the train once unloading is done.

Methods/Techniques used are:


Resetable Timers by a pulse signal

Filtering two sets of signals to their intersection

Delay and extend a pulse signal by specific amounts. (E.g. receive a signal of A=1 for one tick and delay it by 1 second and also extend it's duration to 1 second)

Constant Combinator for adjustable storage limit signals

Filter inserters with 'Mode of operation' = 'Set filters'

Decider and Arithmetic combinators in shapes and sizes

And now, the known issue I have with this setup:

All trains will stay at the station for the same duration - the time it takes to fully unload the train ( ~ 15 seconds with all inserter bonuses researched - or whatever value you like - but it's fixed).

If there's a popular demand to it, I'll be making a follow up on how to send off the train whenever the storage limit has been reached - so that is does not have to wait the full duration.

I've given it some thought and I guess it will increase the amount of combinator logic by roughly 25-50%.

This guide can be reduced to only the 'unloading' section once factorio 0.15 is out, which enables us to read train contents properly. The above problem also won't be an issue anymore.

Register Train And Loaded Item Type, Reset After Unloading

Smart Unloading Train Stop image 23
Smart Unloading Train Stop image 24

This part is responsible for checking if a train (with load) is currently stationed at the train stop.

The inserter at the rail will put a single item (3 if you researched inserter bonus to max) into the steel chest. Once the unloading is done, the second inserter will put the item on the belt and transfer it to another section, which is responsible for loading the item back onto the train and sending a signal to the train to make it leave the station.

First, lets have a closer look at the inserter (A) that is responsible for retrieving a single item from the train. It's logic consists of the combinators on the left:

The Combinators (B-J) compute the 'active' condition of Inserter (A), which is Signal (GREEN=2).

The conditions are straight forward:

We want to enable the inserter when the chest is empty, to only activate the Inserter for a single turn. (i.e, extract a single item from the cargo container. Or three, if you have inserter bonus researched)

Wait until unloading is done, the item has been returned to the container and the train has left the station.

We want the inserter (A) to be active when both conditions are met.

Now, the implementation:

Each condition is represented by Signal (GREEN), thats why we set the enabled condition of inserter (A) to Signal (GREEN) = 2.

The first step is pretty easy:

The steel chest is connected to Decider (B), which checks if the chest is empty and sends signal (GREEN) to the inserter (A) if the condition is met.

The second step requires a timer (Combinators F + G), that counts upwards (+1 each tick) until unloading is done.

How long it takes to unload the train depends on your researched inserter stack bonus and the type of inserters (obviously). The fastest is 12 items per swing the stack inserter (+11 from science) where 875 ticks (roughly 14.5 seconds) works well. The number of ticks is stored in the Combinator (J) as Signal (W, wait time). Adjust it to meet your inserter speed. (I have only tested maxed stack inserters).

But this is not enough, we also need to include the time it takes to remove the item from the chest, put it on the belt and return it to the cargo container (reset for the next train) once unloading is done.

For that, we use a calculator (Arithmetic Combinator) (uppercase letter i).

It takes the wait time (Signal W) from Combinator (J), adds 300 (i found this out by trial-and-error) and sends it to another decider (H) will checks if the clock time (Signal (A)) of Decider (F) has exceeded the wait time. If so, it will send Signal (GREEN) to the inserter (A).

You may have noticed that I did not mention Combinators C,D,E yet. Well, here it is:

The timer keeps counting upwards (until 2G, then resets. This is 385 days, you should be safe to not run into any issues with this setting).

This is a problem, because it would keep one of the two Signal (GREEN) for the inserter active once the wait time has been exceed. To fix this, we need to reset the timer back to zero every time the inserter moves an item from the container to the chest (i.e: non-empty train arrives).

How to do this is also not too hard:

We read the hand contents of Inserter (A) and send it to Decider (C) (e.g Signal COPPER=1) for one tick (pulse). One tick is enough, as we want to reset the timer only once, not for each tick(duration) it takes to physically move the item.

Decider (C) then checks if there is any Signal from Inserter (A), and if so outputs Signal (ZERO=1).

We now need to get the current value of Signal A, convert it to negative and add it to itself (resulting in zero):

Signal (ZERO=1) is therefore sent to a calculator that turns it to negative (ZERO=-1) [1 * -1 = -1].

Signal (ZERO=-1) along with Signal (A) from the Timer Decider (F) is sent to a second calculator which will multiply both values and thus return negative (Signal A) [A * -1 = -A].

Now that we have the inverted value, we send it back to the Timer Decider (F), resulting in a reset to 0.

Remember, we only do this for a single tick.

The whole process is inactive as long as the inserter (A) is inactive, because of the filter that Decider (C) applies.

This results in us having a chest with a single item that indicates whether a train is stationed at the train stop, and which item type it has loaded. Yay!

The next two sections cover how to reset the station logic by removing the item from the chest, putting in onto the belt, transport it back into the container and send off the train.

Reset Station Logic For Next Train (Part 1: Remove Identity Item From Chest After Unloading)

Smart Unloading Train Stop image 57

This section shows you how to (and when) to remove the item from the chest and put it back into the train. This is crucial, because we only need the item to check if a train is at the station, and which item type is loaded. We don't want these 'identifier' items up and have to clean them up.

First, let's have a look at the circuit network settings:

We need two steps to return the item:

Wait until unloading is done and put item on belt (We'll use another timer here)

Wait until item has been put back into the container and send train off (Covered in the next section)

Note: We only want to apply these steps if the steel chest is not empty. (I.e: Start the timer as soon as we receive an item from the steps in the previous section)

Again, step one is fairly simple:

We have a Timer Decider (K) which works a bit differently compared to the previous Timer Decider:

Decider (L) takes the chest content, and sends signal (A=1) to the Timer Decider (K) to turn it on.

Timer Decider (K) will only count upwards while Signal (A) is greater than zero. (Don't get confused, both networks are isolated, so Signal (A) from the previous section will not interfere with Signal (A) of this section).

This allows us to keep the timing disabled by bringing Signal (A) to the negative when the chest is empty.

And we will do it like so:

Decider (N) takes the chest content and checks if it is empty. If it is, it will output Signal (A=1) to calculator (M) which converts the signal to -1G (basically negative infinity).

The negative signal is then sent to the Timer Decider (K) to keep it turned off.

As soon as we receive an item from Inserter of the previous section, the negative signal disappears and the timer starts counting and outputs the value via Signal (A) to Inserter (N).

Inserter (N) also takes the wait Signal (W) (our unloading time in ticks, remember?) from Constant (J) and will activate once Signal (A) exceeds the wait time. Once activated, the item gets removed from the chest, put on the belt and the timer stops.

The next section will cover how to send off the train once the item has been returned to the container.

(You guessed it, another timer - but a special one)

Reset Station Logic For Next Train (Part 2: Return Item To Train And Send It Off)

Smart Unloading Train Stop image 77

This section show you how to send off the train once the item on the belt is put back into the cargo container.

Here's what we want to do:

Pickup item from belt and put it into the container

Wait until item has been inserted into the container

Give train a signal to leave the station

There is just one problem:

The inserter can report a signal when it has something in it's hand - but we need to know when it has removed something from it's hand. Otherwise the train would leave as soon as the inserter picks up the item from the belt - which results in the inserter having the item stuck in it's hand until the next train arrives. Not good!

So, what do we do? - Easy:

We use the inserter's signal, and wait a few ticks before we send off the train.

This is the circuit network we need:

First, lets have a look at the Timer Decider (F). It works the same way as the one from the first section - counting up until 2G (~380 days - let's say infinity).

We need to reset this counter every time the inserter moves an item.

This works the same as in section 1, so i'm going to skip explaining it again.

In short: Take signal from inserter, check if there is something, convert signal to -1, multiply -1 with the current value of the timer => this sets the timer back to zero.

What we do next is the following:

We want to delay the signal for a few ticks (10 is enough, thats 1/6th of a second).

We also want to extend the signal to last for 60 ticks (1 second). Why? Because we have a light attached to the signal for visualization purposes and it's nice to have it flash for longer than 1/60th of a second. You do not need the light, nor the extended signal for the system to function properly.

So, the task is clear: Delay and extend a pulse signal.

This is how to do it:

First, we convert the pulse signal to a timer and reset it every time a pulse signal is received (that's done in the steps above).

Next, we send Signal (A) from the Timer Decider (F) to two other Deciders (G + H).

Decider (H) checks if the signal is greater than 10 (i.e: delay by 10 ticks) and if so, outputs Signal (GREEN=1).

Decider (G) checks if the value less than 70 (i.e: extend by 60 ticks, because we delay by 10 ticks), which also sends Signal (GREEN=1) if the condition is met.

Both Deciders (G + H) send their respective signals to a third Decider (H) which will check if both conditions are met - Signal (GREEN=2). If this is true, it will send a Signal(GREEN=1) to the train station and the light (K).

It's now possible to setup the wait condition for the train:

Signal (GREEN>1).

But! You also need to set a "Time passed" wait condition of 20 seconds or more (longer than it takes to fully unload and return the identification item to the train).

The reasoning behind it is:

If an empty train arrives (or at least the first cargo wagon is empty), there is no item that the station could use as identification item - so it does not know that a train is currently sitting at the station and it won't do anything.

So, just set the train to leave on it's own, if it has to wait longer than 20 seconds.

But beware!

If the wait time is too short, the train will leave before the identification item has returned to the train - this will mess up the whole system:

The next train that arrives will have one identification item removed, and the previous stuck one immediately inserted - the train will leave and the problem starts over.

Unfortunately, I was not yet able to think of a way to automagically fix this. :(

The next section covers the main (and most complex) logic of this project: Unloading the train! Finally!

Unloading The Train At Max Speed

Smart Unloading Train Stop image 114

This section is the heart of this build. The previous three sections you read before are only required because there is no easy way (without mods, of course) to know if a train is stationed and which items it has loaded.

The concept I have is the following:

We have one constant combinator that is used to specify which items we unload, and how many of each item we want in storage.

The conditions that we need to implement with combinator logic are:

Does the train have an item loaded that we want to unload?

Is the currently stored amount of this item less than what we want?

Sounds easy- right? Well, lets see:

Lets get into the details.

The setup has three 3 parts:

Get the current amount of items stored and convert them to negative.

Get the amount of items we want stored, filtered to the identification item in the steel chest.

Combine both signals and activate the inserters if the item signal is greater than zero

Constant Combinator (C) is our source for the information of how much of each item we want to have stored (and therefore also which types of item we want to unload).

It's trivial to set up: If you want 10k iron plate stored, let it emit a Signal (IRON_PLATE=10k). You can have multiple item types in here, each with a different max stored setting if you like.

The Decider (G) also straight forward.

You can see two wires attached to it's input.

One will send the current amount of items, the other one the number of items we have stored (converted to negative).

If the result is positive, it is redirected to the insertes to activated.

So, it's time to get to those two signals.

The first thing we need to to is filter two sets of signals to their intersection[] .

In our case, Set A is the content of the steel chest, which only contains one item. Let's say 3 Copper Plate (3 if you stack inserter bonus is maxed out).

Set B is the content of the Constant Combinator (A). Let's say 1,000 Copper Plate and 1,000 Iron Plate.

The filtering works like this:

Normalize Set A to a value of 1 - we do this by using Combinator (A), which takes any input signals and returns the same signals with a value of 1.

We then multiply each signal of Set A (only copper plate in our case, COPPER from now on) by 2M to Set A. We want to choose a number big enough to always exceed the storage limit!

So the result of our example would be Signal(COPPER=1) * 2M = Signal(COPPER=2,000,000) 2,000,000. This is done in Calculator (B).

This result is now added to the defined storage limits of Set B (Content of Combinator (C).

The addition calculation happens automatically by attaching the output of Calculator (B) and Combinator (C) to the input of Decider (D).

The result of this addion is two signals:

Signal(COPPER=2,001,000) and Signal(IRON=2,000,000).

To now actually filter the result to the desired Signal(COPPER), we simply take 'each' input greater than 2M and output them - see configuraiton of Decider (D).

The filtered Signal is now only Signal(COPPER=2,001,000). The requirement is to have value stored in the combinator - the storage limit of copper plates.

This is done by simply sending the Signal(COPPER=2,001,000) to Calculator (E) which subtracts 2M and outputs the result.

We now have one of the two signals required and send it to the final Decider (G).

The other signal, as already mentioned, is our current storage turned to negative - this is really easy:

Connect all storage chest with wire and then connect one of them to Calculator (F).

Calculator (F) simply multiplies 'each' signal by -1. That's it!

All that's left is connect the output of Calculator(F) to the input of Decider (G).

Calculation of the difference happens automatically, and Decider (G) will only pass on positive Signals.

Here are two example calculations of the whole process:

Steel Chest: 3 Copper Platte (Example A), 3 Iron Plate (Example B)

Storage Limit (Constant Combinator (C)): 1K Copper Plate, 1k Iron Plate.

Current Storage: 1100 Iron Plate, 500 Copper Plate

Example A:

As described above, we will have a Signal of Signal(COPPER=1,000) as ouput of the filtering process (Calculator (D)) - the first input to the final Decider (D).

The second signal, our negative storage content is Signal(COPPER=-500) and Signal(IRON=-1,100).

Combining both sets results in

Signal(COPPER=1000)-Signal(COPPER=-500) = Signal(COPPER=500)

and Signal(IRON=-1,100).

As the Decider only passes through signals > 0, only Signal(COPPER=500) is sent to the Inserters (H) to activate them.

Example B:

Filtered output of Calculator (D) = Signal(IRON=1000).

Negative storage content = Signal(IRON=-1,100) and Signal (COPPER=-500).

Combination Result:

Signal(IRON=-1,100) + Signal(IRON=1000) = Signal(IRON=-100)

and SIGNAL(COPPER=-500).

Both signals are negative. This means that no signal is passed to the inserters and they will be inactive.

Note that the steel chest will only ever hold one item (with a stack size varying between 1 and 3, depending on your research).

This means that the intersection of SteelChest and Constant Combinator(C) will also only result in a single signal - or no signal if the chest is empty.

Since the current storage content always converted to negative, it will never be above zero without adding something. W are adding the filtered Constant Combinator result - only one signal. -> Either one or zero signals are sent to the inserters to activate/deactivate the unloading process.

Thanks for reading this guide. I hope you were able to learn something new and that it helps you to build a glorious factory.

Please leave feedback, improvement ideas (content/guide) and anything else you come up with!

-- Pasukaru

Addendum - Blueprint + Map With Working Examples

Savegame with both blueprints in action. (You need the 'Creative Mode' mod for this savegame - not for the blueprints)

Here's the foreman blueprint for the station with perfect timings - as of Factorio 0.14.20 (Build 25315, win64, steam):

[Train stationed for 867 ticks = 14.45 seconds -> Train condition at station should be Signal Green > 0 OR Time passed > 15 seconds]

H4sIAAAAAAAA/91dXY+rOBL9K6087oYRhW0gms1K9x+sNLPah9EqohN3N9oEIiCt22rlvy+Qj44rYFx2YO6dfpnbExsXp8rHp+xyepM/bfN1sn1aLT/TdZ6V y8/PNNvI70uYl+lrlmyXn9XHXi5naSV3s3mW7Op/V0WSZl5Z5fvZ8Tg/dwg0HYr8Od/nRXXTnGmab/PXtKzStbd+k2Xl7ZOyTN+lty/y93Qji/opx7nMqrRK ZWPwqVN5eC6rpErzbDbf52Xa/Gv5+X3psfnH0gO/GVrfEsC0pQdh0zT6apkUafW2k63R+e45zZIqL3Cn1pL4F3Gcb9JCrtsPwnkNe1Xk29WzfEve07xYfn49 bFV/uGmfUL/oS1qU1UqF7T0tqkOyvSB3+tD7z+zYPLa2PauWwIN5vpdF+x7L2d9n8/xQ7Q/GTzq2z8pO9tZm/DGD2X+Xn6+FlPV7fbaO+Film2XYNP1jFnR/ KubrtFgf0qr5BY7NzwW8jVw3fh1CLlKRCzqQOz/JErZvNWylbPoSUN7tk6IxeTn7JwnZFqH2CfuP2t5DVq1einy3SrP6CcuXZFvKHuQLuVGQhcUttEHd6x59 jppoHMUWinMucaTxDvwiOiK7yz8v6baSRTNpzQGukVlGgZifeck8HrkacfObj4KQGIAwWQBe563vEFzfegOrKg6mcRWpMaPgB8MhF/h9MacdSOsoE5qNDF3l zLIyWb/dOizw259bsv0byWunBxp6J+id0rjlwoF5xSRx34ek/QS4PtFxDsT9c6ARCr2YB3E/6MOMKjoJtUsq9BHqrZyqQagj0ttvk0peGVU0+F4oda7pnRZ5 1t83MA1XTRBe1aEKQoAkVnczs1ZYrnW3At+sGUfNDJZIfvJo+Ogl8tvVKTC0QOplA5B59iTKxARylqjL/Lq5NQd/MyZgLLtuuYEFpuSs80K5S7Zbb5vs9j3h 1IJ/D/jlgVe0KWAn2Uf1lmavOilynB9KWT9+m9eB2rKpoSRjWDfQswCDKfRAEXZeifBi9I/p1Zgu3EAj1SAkRN+8P2HrH8+COqCDOkbRaIoz69z+6s0JCIIR ki4NoIbJyejzwoQYHjMrKMkv16kwDary+76QZelVRZKVzRrvPcstliCLzlWbayhXZsnzVq42adn8t53fVxsKmWxWb0m9ijX9aytL9fPL/z013OUbufTtDBY/ gsGDcRud0e1awh6bT4yWSegitWNDQhermoTByPVxZ6x26bHxXf+SlJWXZqUsainbbSchRK1kjPNe3nEIC6tNlK6NEvoWRxeCoyhvPJE8mGh3g8e65NoxczGd KFPsEHnjYYi3ha3wHGTx8Mri+tn8kzA6QZEHms2hAM97jfbjah50c7rWdejE76J29LzrnG3yxy/UX4cglxmi+HU50YnKPWDgC93OX2juXYjVnQHfcqOFT5At +Y/iet88SWLGOyVOOVKLIRvm/B8rR/IfkiO1J3p9sKpbVVapp0FoOrL/uyyGgKVxxQTJp3r+ZQUs+/mAfSQJK/AOHlRfsqRDVuPxWtRDbzQpMsf5x/nkozFz 9rUDWyXr/3mnLfm+hOacxjLzhKZJl1b5y+qLXsEYErQSAVMwGKqc6bScn3eRh8OdocG5MrhB1kcAySrrG9QTD8rq1FULOtM6jYBgol+OlZWU25P/ujE0dpd6 SK/u4DI+/AKBpoBCfYOW3ObPSdG2Mp864k+cOjxCsA+bG05pLovUhEKz/c/BgQRCYlQxVc9y7jC2cCOgdpPAdmxGHRu994IcPmzSaFfDR/hkc/mk5qr0wkMH z3IqT2rqj+rwVn4VDnYBNeKE6kIguxAmdWGomuuiTHwqVAt1bE6Fyp8SKaHSmAjJjp3WXF81N7B3LNWvAh1Jx1SkgkmBQjOAvERMOl+FKiKEA7UFVLeqa2no 2w9NJVWhErogq8BJV3GhLgGhw9Sj6h2hCoiQTKmTquVQDeaQTKmTpiJCXa5CB/1Ole+hGv+hg4SmqvdQXUdCRvURfRPBJaJUMo/IAnrSfaFQXShDBzKnbjOE KplHDhxF3ZAKVSEVkskcJhVSkToBIvIEWEwaUmjtWdj7Fai6L1LpPHLYZFhQY0pd9yJy1gWTas5QXUoih8QZqDIuUkknIqtzmHSPIVIZPSYzOkyq/SKV3CIH SgfqlkikcnrswOlAFZ6RqlAiOqlPqjxjldRjMqnDpNIzUlk9cmF1qvaMVVaPHVgdqOIzUmk9ptP6pHouUmkdhIufqLIqRtX+KD9fH4p3ufGKJN3iK1unG/RK jcUNxnWP17eqq+OptClQDrvNOnLbjoFtR9+yY2zZzxYaW2QsgbGExXI0y5ezxNLSdbahYhubtpNBO/t6Z3vHZGdmAdaYqYwWEQpjTsTvP74WUbkqFDkUbT3w mx18QhkpA5d6Iz4JrGE8t79G91PiyibB9Qe6poihVQtndffp2y3m3upPX3NKi6p18Yeh7kPNvRuj4tzg4mC9JvyrXoLWu9v4CsKde8l+gIn88CfUSAMYf5WK Np6H2co3A/GvWCQN+ovSvuaODK3y1O+uPD298OzuoQb3PdETbzWfcfmqr/8qgccVsgE4pLJna33TTBYVqwHEnY4zuFjZDHntZ1DpeudlCrbsMVWqiDdcqgQF DXdAt14gcNhBPJcoEgbnyOvWpZ7jzYqmcltFiF6hJ8Y3Em1DBS5FXYzoxgCpicC9KJAQQ4i1Anr1HR/dPYGPjCQXaVyKUsc0Ege6IBsJ4xuJKCOIHGINqIGO cpKAXlvsj4+QQEaST/smsBFNWuay5PlUL4ZocIeqNvLYiKcZ/RRqfOcgScDwvRfTYs4RbWRoJjKXQ1eiDxkic+ZwPBZQx0Yczcj1c+OvIwzJAeZA0VQpwtDy wMgMPb5WY4igGZmgxxe9OBd0ublETUkY4mfuwM/UjIQhfuZkfh49TQecK3MyP8ej24iuCYHLfRziVkITL+rYDvwcU8dG/Ey/vLgY3zeInzl5DYHxFSK6UwXc YTNqQXUiWkRcri8CVSGi+4BAvxAI48svdIUMhMPyAFQNhC54gqBr6PFFEMd1QWSShvG3JdCtLXC5WgRUqYZuq4FwqTKj7hqhm31Av14E4wtFdPEL6PcPYXyl iG4+uRXAUaUiuiQGwoWpqVoRXbzC1XeEUsXx3BPjOHcpOycKsVjvHF2t2V3hEZh084KmPop3FywN9gu6C6QuJ5+DpSPQ7cTpviZedzLf89X9Tb0cG2zFTVr5 Jo2MnmRkVFt6N9wqVFvpYu4uBoRxN94dqv31t6wpyYu6z4Kb5t4pHHCYnoQs+kYkw6kRYzuNagDvu4nh17t/u8jk7U70gr8e+8vK3r/x1fwhmfA43JCZtWu/ 0uumXa/JjA9YrPEHa+I3tujn2/VrHWnTL7Tsxy37WeISWOIClriAJS5giQtY4gKWuFjCYomKbbBYdbNDxG4suxezQ9HOZZYBYhmPluFvOdssJ7cll1hSlyVT WhKz5TpguexYrnKsA5LjWSj/tkuK6unf2TZPNmn2+vR78y3MT7+dFvIn7+lfsnipOz39nu7a0sVfC1kdiuxp9avMNv8HnNUsvkd1AAA=

And here is a Blueprint that has some buffers in all wait times - in case the above one does not work anymore because of changes to inserter speed or whatever:

[Train stationed for 1000 ticks = 16.66 seconds -> Train condition at station should be Signal Green > 0 OR Time passed > 15 seconds]

H4sIAAAAAAAA/91dXY+rOBL9K6087oYRhc1HNMtKd//CzGofRquITtzdaAlEQFq31cp/XyAfHVfAuOzA3Dv9MrcnNi5OlY9P2eX0tnjKik2SPa3jz3RT5FX8 +ZnmW/E9hmWVvuZJFn/WH3sRL9Ja7BbLPNk1/67LJM2dqi72i+Nxee7gKTqUxXOxL8r6pjlTNM+K17Sq042zeRNV7eyTqkrfhbMvi/d0K8rmKcelyOu0TkVr 8KlTdXiu6qROi3yx3BdV2v4r/vweO2z5ETvgtkOrWwLotnQgaJuGXy2TMq3fdqIzutg9p3lSFyXu1FkS/eIfl9u0FJvug2DZwF6XRbZ+Fm/Je1qU8efXw9bN h9vuCc2LvqRlVa9l2N7Tsj4k2QW504fOfxbH9rGN7Xkde667LPai7N4jXvx9sSwO9f6g/aRj96z8ZG9jxh8LWPw3/nwthWje67NzxMc63cZB2/SPhdf/qb/c pOXmkNbtL3Bsfy7gbcWm9esYcqGMnNeD3PlJhrB9a2CrRNuXgPJun5StyfHinyRkO4S6J+w/GnsPeb1+KYvdOs2bJ8QvSVaJAeRLsZWQhdUttF7T6x59jpoo HMVWknMucaTwDvzi90R2n39e0qwWZTtp9QFukImjJobPvKQfj1yOuOXNR15ADECYLQCv89a1CK5vg4FVlwfduArlmJHwg/GQ89yhmFMOpHSUDs2Gmq6yZlmR bN4Q0bY/t2T7N5LXTg/U9I43OKVxy5UF8/qzxP0QkuYT4PpEyzkQDc+BVigMYu5Fw6CPM6rfS6h9UmGIUG/lVANCE5HOPktqcWVU372h1KWid1oW+XBfTzdc FUF4VYcyCB6SWP3N9FphudbfCly9Zhw101gi+cmjwaOXyG9Xp8DYAqmWDUDm2ZMo82eQs0Rd5jbNjTn4mzYBY9l1yw3M0yVnlReqXZJlTpbs9gPh1IF/D/jl gVe0KWAn+Uf9luavKilyXB4q0Tw+K5pA7dhUU5IxrBvoWYDGFHqgCDuvRHgx+sf8akwVbqCQahAQom85nLANj2dAHdBDHZNoNMmZTW5/9eYMBMEISZcCUM3k ZPJ5oUMMj5kVlOSXq1SYAlXxfV+KqnLqMsmrdo13nkWGJciqd9XmCsoVefKcifU2rdr/dvP7akMpku36LWlWsbZ/Y2Ulf375v6eGu2IrYtfMYP9HMHg0bsMz un1L2GPzickyCVWk9mxIqGJVkTBouT7qjdU+PTa961+SqnbSvBJlI2X77SSEqJGMsd7LO45hYbSJ0rdRQt/i6ENwEuWNJ5IDM+1u8EiVXFtmLroTZY4dImc6 DPG2sBGeoyweXFlcPZt/EkYnKHJPsTnk4Xmv0H5czoNuTtf6Dp34XdROnneds03++IX66xDkMkMkv8YznajcAwaur9r5C/S9C5G8M+AabrTwGbIl91Fc7+on SUx7p8QqR+owZOOc/2PlSO5DcqTuRG8IVnmryij11AhNS/Z/F+UYsDSumCH5lM+/jIBlPx+wjyRhCd7Rg+pLlnTIGzxey2borSJF5jj/OJ98tGYuvnZg62Tz P+e0JT+U0JzTWKaf0LTp0rp4WX/RK2hDglYiYBIGY5UzvZbz8y7yeLgzNDiXBtfI+gggGWV9o3riQVmdvGpBb1qnEBDMH5ZjVS1EdvJfP4ba7pIP6eUdXMbH X8BTFFDIb9CR2/I5KbtW+lPH/xOnDg8R7OPmBnOay0I5oVBs/3OwIIGAGFVM1rOcW4zt2xFQt0lgOjajjo3ee0UOHzZrtMvh47tkc/ms5sr0wgMLz3IqTyrq j5rwln71LewCasT5sguB7EKY1YWBbK6NMnGpUK3ksTkVKndOpHyZxvyA7Nh5zXVlcz1zx1L96qMj6YiKlDcrUGgGkJeIWeerL4sI34LaPKpb5bU0cM2HppKq LxO6T1aBs67ivrwEBBZTj6p3fFlABGRKnVUtB3IwB2RKnTUV8eXlKrDQ71T5HsjxH1hIaKp6D+R1JGBUH9E3EWwiSibzkCygZ90XCuSFMrAgc+o2QyCTeWjB UdQNqUAWUgGZzGFWIRXKEyAkT4DVrCGF1p6VuV+BqvtCmc5Di02GFTWm5HUvJGddMKvmDOSlJLRInIEq40KZdEKyOodZ9xhCmdEjMqPDrNovlMkttKB0oG6J hDKnRxacDlThGcoKJaST+qzKM5JJPSKTOswqPUOZ1UMbVqdqz0hm9ciC1YEqPkOZ1iM6rc+q50KZ1sG38RNVVkWo2h/l55tD+S62TpmkGb6ydbpBL9VY3GDc 9Hh9q/s6nkqbPOmwW68jN+3omXZ0DTtGhv1MoTFFxhAYQ1gMRzN8OUMsDV1nGiqmsWk6GZSzb3C290x2phdgrZnSaCGhMOZE/O7jaxHRvS+Lqq0HfrWDS6gj ZWBTcMRnwTWCpfk9up8SVzZTvP4w9xQxtHLlrOpCfbfHPFj+6SqOaVG5Lv4wUH2ouHijVZ3rXRysFoV/1VvQandr30G4cy/ZDzCTH/6EImkA7e9SUcbzOFu5 eiD+FaukQX1T2lVckqGVnrr9paenF17cPVTjwid64q3o065fddXfJfC4SjYAi1z2bK2rm8qiajWAqNdxGjcr2yGv/TRKXe+8TMGWPaZMFfGGTZmgT8Md0LUX 8Cy2EM81ioTBOfK6ca3ndLOiLd2WEaKX6PnTG4n2oTybqi5GdKOH1IRnXxVIiCHEWh69/I5P7h7PRUaSqzQuValTGokD3ScbCdMbiSjDCy1iDaiBjnISj15c 7E6PkI+MJB/3zWAjmrTMZslzqV4M0OAWZW3ksRFPM/ox1PTOQZKA4YsvutWcE9rI0ExkNqeuRB8yRObM4nzMo46NOJqRC+imX0cYkgPMgqKpUoSh5YGRGXp6 rcYQQTMyQU8venEuaHN1iZqSMMTP3IKfqRkJQ/zMyfw8eZoOOFfmZH6OJrcR3RMCmws5xK2ENl7ksS34OaKOjfiZfntxNb1vED9z8hoC0ytEdKkKuMVm1Irq RLSI2NxfBKpCRBcCgX4jEKaXX+gOGfgWywNQNRC64Qk+XUNPL4I4LgwikzRMvy2Brm2Bzd0ioEo1dF0NfJsyM+quEbraB/T7RTC9UEQ3v4B+ARGmV4ro6pNd BRxVKqJbYuDbMDVVK6KbV7j8jlCrOJ17IhznNnXnRCEWqZ2jKja7qzwCnW6O1xZI8f6KpdF+Xn+F1OXkc7R0BPqdON/3xKtO5ge+u78tmGOjrbhOK1enkdaT tIzqau/GWwVyK1XM3cWAr92N94fqcAEua2vywv6z4La5cwoHHKYnIYu+EklzakTYTq0iwPtu/vjr3b9dqPN2J3rB34/9ZeXgH/lq/5JMcBxvyPTadd/pddNu 0GTGRyxW+IO1UyEy6OcZ9nPN+nUBYNIvMOxniItniItniAsY4gKGuIAhLmCICxjiYgiLISqmwWLUzQwRs7HMXswMRTOXGQaIYTwahr/hbDOc3IZcYkhdhkxp SMyG64DhsmO4yvUtqsezwP5tl5T107/zrEi2af769Hv79c1Pv50EwJPz9K/Dy4toNPXT7+muq3n8tRT1ocyf1r+KfPt/WZykToF1AAA=


More Factorio guilds