function autoJobs() {
        state.jobManager.calculateCraftingMaxs();
        let jobList = state.jobManager.managedPriorityList();

        // No jobs unlocked yet
        if (jobList.length === 0) {
            return;
        }

        let quarryWorkerIndex = jobList.indexOf(state.jobs.QuarryWorker);
        let lumberjackIndex = -1;
        let scavengerIndex = jobList.indexOf(state.jobs.Scavenger);
        let farmerIndex = jobList.indexOf(state.jobs.Farmer);

        if (isEvilRace() && !isEvilUniverse()) {
            lumberjackIndex = jobList.indexOf(state.jobs.Farmer);
        } else {
            lumberjackIndex = jobList.indexOf(state.jobs.Lumberjack);
        }

        let breakpoint0Max = 0;
        let breakpoint1Max = 0;

        // Cath / Balorg / Imp race doesn't have farmers, unemployed are their farmers
        if (isHunterRace()) {
            for (let i = 0; i < jobList.length; i++) {
                const job = jobList[i];
                breakpoint0Max += job.breakpointEmployees(0, false);
                breakpoint1Max += job.breakpointEmployees(1, false);
            }

            log("autoJobs", "Max breakpoint 0: " + breakpoint0Max)
            log("autoJobs", "Max breakpoint 1: " + breakpoint1Max)
        }

        let availableEmployees = state.jobManager.totalEmployees;
        let requiredJobs = [];
        let jobAdjustments = [];

        log("autoJobs", "Total employees: " + availableEmployees);

        // First figure out how many farmers are required
        if (state.jobs.Farmer.isManaged()) {
            if (!state.jobs.Lumberjack.isUnlocked() && !state.jobs.QuarryWorker.isUnlocked() && game.global.race.species !== "entish") {
                // No other jobs are unlocked - everyone on farming!
                requiredJobs.push(availableEmployees);
                log("autoJobs", "Pushing all farmers")
            } else if (resources.Population.currentQuantity > state.lastPopulationCount) {
                let populationChange = resources.Population.currentQuantity - state.lastPopulationCount;
                let farmerChange = state.jobs.Farmer.count - state.lastFarmerCount;

                if (populationChange === farmerChange && resources.Food.rateOfChange > 0) {
                    requiredJobs.push(Math.max(state.jobs.Farmer.count - populationChange, 0));
                    log("autoJobs", "Removing a farmer due to population growth")
                } else {
                    requiredJobs.push(state.jobs.Farmer.count);
                }
            } else if (resources.Food.storageRatio < 0.2 && resources.Food.rateOfChange < 0) {
                // We want food to fluctuate between 0.2 and 0.8 only. We only want to add one per loop until positive
                requiredJobs.push(Math.min(state.jobs.Farmer.count + 1, availableEmployees));
                log("autoJobs", "Adding one farmer")
            } else if (resources.Food.storageRatio > 0.8 && resources.Food.rateOfChange > 0) {
                // We want food to fluctuate between 0.2 and 0.8 only. We only want to remove one per loop until negative
                requiredJobs.push(Math.max(state.jobs.Farmer.count - 1, 0));
                log("autoJobs", "Removing one farmer")
            } else if (isHunterRace() && resources.Food.storageRatio > 0.3 && resources.Food.rateOfChange > resources.Population.currentQuantity / 10) {
                // Carnivore race. Put We've got some food so put them to work!
                requiredJobs.push(Math.max(state.jobs.Farmer.count - 1, 0));
                log("autoJobs", "Removing one farmer - Carnivore")
            } else {
                // We're good; leave farmers as they are
                requiredJobs.push(state.jobs.Farmer.count);
                log("autoJobs", "Leaving current farmers")
            }

            log("autoJobs", "currentQuantity " + resources.Population.currentQuantity + " breakpoint1Max " + breakpoint1Max + " requiredJobs[0] " + requiredJobs[0] + " breakpointEmployees(1) " + state.jobs.Lumberjack.breakpointEmployees(1, false) +  " breakpointEmployees(0) " + state.jobs.Lumberjack.breakpointEmployees(0, false))
            if (isEvilRace() && !isEvilUniverse()) {
                if (resources.Population.currentQuantity > breakpoint0Max && requiredJobs[0] < state.jobs.Lumberjack.breakpointEmployees(1, false)) {
                    log("autoJobs", "Setting required hunters to breakpoint 1")
                    requiredJobs[0] = state.jobs.Lumberjack.breakpointEmployees(1, false);
                } else if (requiredJobs[0] < state.jobs.Lumberjack.breakpointEmployees(0, false)) {
                    log("autoJobs", "Setting required hunters to breakpoint 0")
                    requiredJobs[0] = state.jobs.Lumberjack.breakpointEmployees(0, false);
                }
            }

            if (requiredJobs[0] < 0) { requiredJobs[0] = 0; }

            jobAdjustments.push(requiredJobs[0] - state.jobs.Farmer.count);
            availableEmployees -= requiredJobs[0];
        }

        let availableCraftsmen = state.jobManager.maxCraftsmen;

        for (let i = 0; i < state.jobManager.maxJobBreakpoints; i++) {
            for (let j = 0; j < jobList.length; j++) {
                const job = jobList[j];

                // We've already done the farmer above
                if (job === state.jobs.Farmer) {
                    continue;
                }

                if (i !== 0) {
                    // If we're going up to the next breakpoint then add back the workers from this job from the last one
                    // so that we don't double-take them
                    availableEmployees += requiredJobs[j];

                    // We have to keep track of craftsmen separately as they have a special max number of total craftsmen
                    if (job.isCraftsman()) {
                        availableCraftsmen += requiredJobs[j];
                    }
                }

                log("autoJobs", "job " + job._originalId + " job.breakpointEmployees(i) " + job.breakpointEmployees(i, false) + " availableEmployees " + availableEmployees);
                let jobsToAssign = 0;
                if (!job.isCraftsman()) {
                    jobsToAssign = Math.min(availableEmployees, job.breakpointEmployees(i, false));
                } else {
                    // We have to keep track of craftsmen separately as they have a special max number of total craftsmen
                    jobsToAssign = Math.min(availableEmployees, availableCraftsmen, job.breakpointEmployees(i, false));
                }

                // Don't assign bankers if our money is maxed and bankers aren't contributing to our money storage cap
                if (job === state.jobs.Banker && !isResearchUnlocked("swiss_banking") && resources.Money.storageRatio > 0.98) {
                    jobsToAssign = 0;
                }

                // Races with the Intelligent trait get bonus production based on the number of professors and scientists
                // Only unassign them when knowledge is max if the race is not intelligent
                // Once we've research shotgun sequencing we get boost and soon autoassemble genes so stop unassigning
                if (!isIntelligentRace() && !isResearchUnlocked("shotgun_sequencing")) {
                    // Don't assign professors if our knowledge is maxed and professors aren't contributing to our temple bonus
                    if (job === state.jobs.Professor && !isResearchUnlocked("indoctrination") && resources.Knowledge.storageRatio > 0.98) {
                        jobsToAssign = 0;
                    }

                    // Don't assign scientists if our knowledge is maxed and scientists aren't contributing to our knowledge cap
                    if (job === state.jobs.Scientist && !isResearchUnlocked("scientific_journal") && resources.Knowledge.storageRatio > 0.98) {
                        jobsToAssign = 0;
                    }
                }

                if (job === state.jobs.CementWorker) {
                    let currentCementWorkers = job.count;
                    log("autoJobs", "jobsToAssign: " + jobsToAssign + ", currentCementWorkers" + currentCementWorkers + ", resources.stone.rateOfChange " + resources.Stone.rateOfChange);

                    if (jobsToAssign < currentCementWorkers) {
                        // great, remove workers as we want less than we have
                    } else if (jobsToAssign >= currentCementWorkers && resources.Stone.rateOfChange < 5) {
                        // If we're making less than 5 stone then lets remove a cement worker even if we want more
                        jobsToAssign = job.count - 1;
                    } else if (jobsToAssign > job.count && resources.Stone.rateOfChange > 8) {
                        // If we want more cement workers and we're making more than 8 stone then add a cement worker
                        jobsToAssign = job.count + 1;
                    } else {
                        // We're not making enough stone to add a new cement worker so leave it
                        jobsToAssign = job.count;
                    }
                }

                if (i === 0) {
                    requiredJobs.push(jobsToAssign);
                    jobAdjustments.push(jobsToAssign - job.count);
                } else {
                    requiredJobs[j] = jobsToAssign;
                    jobAdjustments[j] = jobsToAssign - job.count;
                }

                availableEmployees -= jobsToAssign;

                // We have to keep track of craftsmen separately as they have a special max number of total craftsmen
                if (job.isCraftsman()) {
                    availableCraftsmen -= jobsToAssign;
                }

                log("autoJobs", "job " + job._originalId +  " has jobsToAssign: " + jobsToAssign + ", availableEmployees: " + availableEmployees + ", availableCraftsmen: " + availableCraftsmen);
            }

            // No more workers available
            if (availableEmployees <= 0) {
                break;
            }
        }

        let splitJobs = [];
        if (lumberjackIndex !== -1) splitJobs.push( { jobIndex: lumberjackIndex, job: state.jobs.Lumberjack, weighting: settings.jobLumberWeighting, completed: false } );
        if (quarryWorkerIndex !== -1) splitJobs.push( { jobIndex: quarryWorkerIndex, job: state.jobs.QuarryWorker, weighting: settings.jobQuarryWeighting, completed: false });
        if (scavengerIndex !== -1) splitJobs.push( { jobIndex: scavengerIndex, job: state.jobs.Scavenger, weighting: settings.jobScavengerWeighting, completed: false });
        if (farmerIndex !== -1 && game.global.race.species === "entish") splitJobs.push( { jobIndex: farmerIndex, job: state.jobs.Farmer, weighting: 1, completed: false });

        // Balance lumberjacks, quarry workers and scavengers if they are unlocked
        if (splitJobs.length > 0) {
            let minLumberjacks = 0;
            let totalWeighting = 0;

            if (isEvilRace() && !isEvilUniverse() && lumberjackIndex !== -1) {
                // Evil races are a little bit different. Their "umemployed" workers act as both farmers and lumberjacks
                // We need to keep a minimum number on farming.
                minLumberjacks = requiredJobs[lumberjackIndex];
            }

            // Reduce jobs required down to 0 and add them to the available employee pool so that we can split them according to weightings
            splitJobs.forEach(jobDetails => {
                availableEmployees += requiredJobs[jobDetails.jobIndex];
                requiredJobs[jobDetails.jobIndex] = 0;
                jobAdjustments[jobDetails.jobIndex] = 0 - jobDetails.job.count;
                totalWeighting += jobDetails.weighting;
            });

            // Bring them all up to breakpoint 0 one each at a time
            while (availableEmployees >= 1 && findArrayIndex(splitJobs, "completed", false) != -1) {
                splitJobs.forEach(jobDetails => {
                    if (availableEmployees <= 0 || requiredJobs[jobDetails.jobIndex] >= jobDetails.job.breakpointEmployees(0, true)) {
                        jobDetails.completed = true;
                        return;
                    }

                    requiredJobs[jobDetails.jobIndex]++;
                    jobAdjustments[jobDetails.jobIndex]++;
                    availableEmployees--;
                });
            }

            // Reset completed for next breakpoint
            splitJobs.forEach(jobDetails => { jobDetails.completed = false; });

            // Bring them all up to breakpoint 1 one each at a time
            while (availableEmployees >= 1 && findArrayIndex(splitJobs, "completed", false) != -1) {
                splitJobs.forEach(jobDetails => {
                    if (availableEmployees <= 0 || requiredJobs[jobDetails.jobIndex] >= jobDetails.job.breakpointEmployees(1, true)) {
                        jobDetails.completed = true;
                        return;
                    }

                    requiredJobs[jobDetails.jobIndex]++;
                    jobAdjustments[jobDetails.jobIndex]++;
                    availableEmployees--;
                });
            }

            // splitJobs.forEach(jobDetails => {
            //     console.log("3 " + jobDetails.job.name + " required " + requiredJobs[jobDetails.jobIndex] + ", adjustment " + jobAdjustments[jobDetails.jobIndex])
            // });
            //console.log(availableEmployees)

            if (availableEmployees > 0) {
                // Split the remainder in accordance to the given weightings
                if (isEvilRace() && !isEvilUniverse() && lumberjackIndex !== -1) {
                    // Lumberjacks are special! for evil races they are also farmers so we need to keep a minimum even if the split doens't have that many
                    let lumberjacks = Math.ceil(availableEmployees * settings.jobLumberWeighting / totalWeighting);
                    lumberjacks = Math.max(minLumberjacks - requiredJobs[lumberjackIndex], lumberjacks);
                    requiredJobs[lumberjackIndex] += lumberjacks;
                    jobAdjustments[lumberjackIndex] += lumberjacks;
                    availableEmployees -= lumberjacks;
                }

                // Perform weighting - need the current available employees to multiply by the weighting
                let startingAvailableEmployees = availableEmployees;

                splitJobs.forEach(jobDetails => {
                    if (availableEmployees <= 0 || (isEvilRace() && !isEvilUniverse() && jobDetails.job === state.jobs.Lumberjack)) {
                        // We've already dealt with evil lumberjacks above. Those dastardly lumberjacks!
                        return;
                    }

                    let workers = Math.ceil(startingAvailableEmployees * jobDetails.weighting / totalWeighting);
                    workers = Math.min(availableEmployees, workers);
                    requiredJobs[jobDetails.jobIndex] += workers;
                    jobAdjustments[jobDetails.jobIndex] += workers;
                    availableEmployees -= workers;
                });

                // Any leftovers assign to the last job
                let jobIndex = splitJobs[splitJobs.length - 1].jobIndex;
                requiredJobs[jobIndex] += availableEmployees;
                jobAdjustments[jobIndex] += availableEmployees;
                availableEmployees -= availableEmployees;
            }
        }

        if (settings.autoCraftsmen && state.jobs.SheetMetal.isManaged() && settings['craft' + state.jobs.SheetMetal.resource.id]) {
            if (state.cityBuildings.Wardenclyffe.count < 18) {
                let sheetMetalIndex = jobList.indexOf(state.jobs.SheetMetal);

                if (sheetMetalIndex != -1 && state.cityBuildings.Cottage.count > 10 && state.cityBuildings.Library.count > 15 && state.cityBuildings.CoalMine.count > 8) {
                    let plywoodIndex = jobList.indexOf(state.jobs.Plywood);
                    let brickIndex = jobList.indexOf(state.jobs.Brick);
                    let wroughtIronIndex = jobList.indexOf(state.jobs.WroughtIron);
                    let additionalSheetMetalJobs = 0;

                    if (plywoodIndex !== -1 && state.jobs.Plywood.isManaged()) {
                        // add plywood jobs above 1 to sheet metal
                        let plywoodJobs = requiredJobs[plywoodIndex];

                        if (plywoodJobs > 1) {
                            requiredJobs[plywoodIndex] = 1;
                            jobAdjustments[plywoodIndex] -= (plywoodJobs - 1);
                            additionalSheetMetalJobs += (plywoodJobs - 1);
                        }
                    }

                    if (brickIndex !== -1 && state.jobs.Brick.isManaged()) {
                        // add brick jobs above 1 to sheet metal
                        let brickJobs = requiredJobs[brickIndex];

                        if (brickJobs > 1) {
                            requiredJobs[brickIndex] = 1;
                            jobAdjustments[brickIndex] -= (brickJobs - 1);
                            additionalSheetMetalJobs += (brickJobs - 1);
                        }
                    }

                    if (wroughtIronIndex !== -1 && state.jobs.WroughtIron.isManaged()) {
                        // add wroughtIron jobs above 1 to sheet metal
                        let wroughtIronJobs = requiredJobs[wroughtIronIndex];

                        if (wroughtIronJobs > 1) {
                            requiredJobs[wroughtIronIndex] = 1;
                            jobAdjustments[wroughtIronIndex] -= (wroughtIronJobs - 1);
                            additionalSheetMetalJobs += (wroughtIronJobs - 1);
                        }
                    }

                    requiredJobs[sheetMetalIndex] += additionalSheetMetalJobs;
                    jobAdjustments[sheetMetalIndex] += additionalSheetMetalJobs;
                }
            }
        }

        for (let i = 0; i < jobAdjustments.length; i++) {
            let adjustment = jobAdjustments[i];
            if (adjustment < 0) {
                // I have no clue how this is undefined... but it can be when the script first starts and playing a carnivore / evil race
                // May have fixed it by moving the evil race / hunter race checks to update state in the automate function
                if (jobList[i] !== undefined) {
                    jobList[i].removeWorkers(-1 * adjustment);
                    log("autoJobs", "Adjusting job " + jobList[i]._originalId + " down by " + adjustment);
                }
            }
        }

        for (let i = 0; i < jobAdjustments.length; i++) {
            let adjustment = jobAdjustments[i];
            if (adjustment > 0) {
                if (jobList[i] !== undefined) {
                    jobList[i].addWorkers(adjustment);
                    log("autoJobs", "Adjusting job " + jobList[i]._originalId + " up by " + adjustment);
                }
            }
        }

        state.lastPopulationCount = resources.Population.currentQuantity;
        state.lastFarmerCount = state.jobs.Farmer.count;
    }