code:
[{
    "default" : {
       "default" : {.
           "default" : {.
                "default" : [
                ],
                "climaxing" : [
                ],
				"pregnant" : [
				]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		},
		"male" : {
			"default" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		},
		"female" : {
			"default" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		}
	},
	"pregnant" : {
		"default" : {
			"default" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		},
		"male" : {
			"default" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		},
		"female" : {
			"default" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			}
		}
	},
	"climax" : {
		"default" : {
			"default" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			}
		},
		"male" : {
			"default" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			}
		},
		"female" : {
			"default" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"avian" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"felin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"floran" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"glitch" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"human" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"hylotl" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"novakid" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			},
			"penguin" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climax" : [
				]
			}
		}
	}
},
{
    "default" : {
        "default" : {
            "default" : {
                "default" : [
					"You've got me from behind, I wonder how long you'll go at it~!",
					"Ooh, I'm so horny all of the sudden~! Keep going~!",
					"My ass is red from all this pounding~!",
					"Grab my hips and plow me~!",
					"Put it in my ass!",
					"Unng! Finger my asshole while you fill me up!"
					"Ooooh~! You've found the perfect spot~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Oh you came already? Let me clean you up~~!"
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avali" : {
                "default" : [
					"Ooooh~~! Your feathers tickle!",
					"So graceful! So rough!",
					"Do you always take your prey from behind~~!"
					"Oh YESS take me like prey!"
                ],
				"pregnant" : [
					"You're so full of eggs, it makes me wet to think about!"
				],
                "climaxing" : [
					"I hope you have your anti-water augment, because we've soaked your pretty feathers fucking me!"
                ]
			},
            "avian" : {
                "default" : [
					"Ooooh~~! Your feathers tickle!",
					"So graceful! So rough!",
					"Do you always take your prey from behind~~!"
                ],
				"pregnant" : [
					"You're so full of eggs, it makes me wet to think about!"
				],
                "climaxing" : [
					"We've soaked your pretty feathers fucking me~~!"
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "ferenox" : {
                "default" : [
					"You know just where to rub me!"
                ],
				"pregnant" : [
					"It feels like a big litter in your belly~!!"
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
					"What's... what's in your pollen?",
					"I've never been this wet before, your nectar is driving me wild!",
					"Your petals are this soaked for me?"
                ],
				"pregnant" : [
					"Your petals are so plump and swollen!"
				],
                "climaxing" : [
					"Your nectar is running everywhere~~"
                ]
			},
            "glitch" : {
                "default" : [
					"Oooohh~ I didn't know you could do that~~!",
					"You're making my pussy tingle~!",
					"Ohmygod! How do you fit me so perfectly? I'm going to c-c-c-cum!",
					"I hope you're waterproof~! I'm about to squirt all over you~!",
					"You didn't tell me you could vibrate~!"
                ],
				"pregnant" : [
					"I can hear the gears in your belly!"
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
					"Your belly turns me on so much!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
					"Your fin is rubbing... my asshole~~~!",
					"You're so slippery! I want to slide on top of you next~!"
					"Your fin is rubbing me just right!",
					"Your rod is so slippery and thick! Can we try it in my asshole?",
					"Your scales are hitting all the right places~~~~!"
                ],
				"pregnant" : [
					"I can feel your eggs moving around, you're so full!"
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
					"O-oh~, your body is so hot against me!",
					"Have you ever had a human girl?"
                ],
				"pregnant" : [
					"Your belly is so hot on my skin!",
					"Your glowing belly is so sexy!"
				],
                "climaxing" : [
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"male" : {
            "default" : {
                "default" : [
					"You've got me from behind, I wonder how long you can last~!",
					"Ooh, I'm so horny all of the sudden~! Keep going~!",
					"I've wanted this for a long time!",
					"Are you going to empty your load inside me?",
					"Unng! You'd better not pull out!",
					"I'm so wet, you could slip right into my asshole~~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"O-oh~! You're cumming~! Unng, fill me up~!",
					"It's running out of me!",
					"So much cum! Spray it inside me until it runs out!~",
					"Mmmm! Yes~! Fill up my womb!",
					"Yess I want you to fill my womb!"
                ]
			},
			"apex" : {
				"default" : [
					"It's so big and so thick!!~",
					"Ohmygod! Human cocks aren't this thiiiiiick!",
					"YESS! Stuff me full with your hairy cock!",
					"OH! Yes! You're MY Big Ape!"
				],
				"pregnant" : [
				],
				"climaxing" : [
					"So much hot cum... just for me!",
					"It's so thick and warmm!",
					"OH you're filling me up! Make me carry your little apes!"
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
					"Hng yess! I want to have your chicks!"
				]
			},
            "avian" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Hng yess! I want to have your chicks!"
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "ferenox" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
					"Ooooh~, your cock tingles",
					"Your scent makes me... it makes me want your cock so badly..."
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Your cum is making me dizzy~!",
					"Your cum tingles! Is it going to make me pregnant?",
					"Plant your seeds inside me!",
					"I want to carry your seedlings!!~~"
                ]
			},
            "glitch" : {
                "default" : [
					"I... I didn't know it could extend like thiiiiiisss!",
					"It's so big... and greasy!",
					"I can feel it twisting inside me!~~~~"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"OH~ This oil... this oil feels so good!",
					"You're squirting your oil down my thighs!",
					"Your oil is so thick and warm!",
					"OH~ That's not just oil... is it.",
					"I hope that's more than just oil, I want you to knock me up~!"
                ]
			},
            "human" : {
                "default" : [
					"Fuck yeah, fill me up!",
					"You're in me just right~!",
					"Are you going to finish in me?"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Oh god yes! Fill me to the brim!",
					"YESSS! Keep cumminnnggggg!",
					"Fill up my womb~~!"
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Yesss, give me your milt!"
                ]
			},
            "novakid" : {
                "default" : [
					"Your rod is burning hot inside me~~!",
					"What will... what will happen if you come inside me?",
					"Your cock is making my belly glowwww!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Your spunk is so hot!",
					"Our juices are glowing together~~!",
					"Your cum is lighting up my pussy!!",
					"I can see it glowing in my womb~~!",
					"Steam is coming out! ohhh it feels so good!!!~",
					"I hope you knocked me up! It feels so hot inside me!"
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"female" : {
            "default" : {
                "default" : [
					"Yes! Pound it into me!",
					"I've been so naughty! Punish me harder~!",
					"Ooh, I'm so horny all of the sudden~! Keep going~!",
					"My thighs are wet with your juices~! I feel so dirty!",
					"Grab my hips and plow me~!",
					"I've wanted this for so long!",
					"I had no idea you were so aggressive~!",
					"Mmmmff~~! Spank me while you do that!~"
                ],
				"pregnant" : [
					"I can feel your pregnant belly against me! I didn't know that would make me so wet!~~"
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
					"Oh! Your grip on me is so strong!",
					"You're so strong, but so soft~!",
					"I can feel your fat pussy rubbing on my ass!",
					"You know how I like it, be rough with me~~!"
				],
				"pregnant" : [
					"Your furry belly is so sexy against me!"
				],
				"climaxing" : [
					"OH! You're gushing all over me!",
					"Your juice is everywhere! It feels so good!",
					"I'm softer than Apex girls.... I hope my pussy is enough for you!",
					"Oh YESS take me! Make me yours!"
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avian" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "ferenox" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "glitch" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
					"You're so soft and lovely. I've wanted you all day~~~~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"You're soaking my asshole... you'd better lick that up!",
					"Save some for when I'm eating your ass!"
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Your pussy is steaming hot!"
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		}
	},
	"pregnant" : {
		"default" : {
			"default" : {
				"default" : [
					"E-easy~! Baby-on-board!",
					"I'm ready to burst but I need this so bad~!",
					"Do you like my pregnant pussy?",
					"I get so wet when I'm pregnant... I need you to lap it up!",
					"Can you feel how full I am?"
				],
				"pregnant" : [
					"It's so sexy that we're pregnant together!"
				],
                "climaxing" : [
					"Yes, pull me closer when you cum!"
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avali" : {
                "default" : [
					"You can be rough with me, I'm not carrying eggs!",
					"Your feathers! I'm more ticklish now that I'm pregnant!!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "avian" : {
                "default" : [
					"You can be rough with me, I'm not carrying eggs!",
					"Your feathers! I'm more ticklish now that I'm pregnant!!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "ferenox" : {
                "default" : [
                ],
				"pregnant" : [
					"I wish I could have... a big litter like yoursss~!"
				],
                "climaxing" : [
					"Oh god, your claws are digging into me! It feels so good!"
                ]
			},
            "floran" : {
                "default" : [
					"... even though I'm pregnant, I can't stop thinking about your nectar!"
                ],
				"pregnant" : [
					"Since we got pregnant, your scent has become... intoxicating..."
				],
                "climaxing" : [
					"Your petals feel so good against my pregnant pussy!"
                ]
			},
            "glitch" : {
                "default" : [
					"Yes! Spank my pregnant ass raw with your gears!"
                ],
				"pregnant" : [
					"I'm getting slick with your oil~~!"
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
					"I want your soft hands all over my pregnant body!",
					"Does my pregnant belly turn you on?"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
					"Ohgod, your scales are rubbing just right! Don't stop!"
                ],
				"pregnant" : [
					"We're both carrying big clutches!"
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
					"Your hands are so hot on my belly!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"male" : {
            "default" : {
                "default" : [
					"Fuck! You're stuffing me so full!",
					"Unload in my pregnant asshole~~!",
					"I'm already pregnant, but I can't get enough cum~!"
					"Being pregnant makes me crave cock!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Mmh~! Fill up my pregnant pussy~!",
					"Your cum is running down my thighs~~~!",
					"Your hot cum is pouring out of me~!",
					"Soon, you'll be able to knock me up~!",
					"Yessss! Please I want to be even more full!"
					"I feel so full, yes~!!"
                ]
			},
			"apex" : {
				"default" : [
					"I need a big ape to fill up my swollen pussy!"
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avian" : {
                "default" : [
					"Your hands feel so soft on my pregnant belly!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
					"I can feel you wriggling inside me!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"This nectar is... so strong! I need more!"
                ]
			},
            "glitch" : {
                "default" : [
					"It's... it's getting bigger inside me~!"
                ],
				"pregnant" : [
					"Yess! Pump it into my pregnant hole!"
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
					"It's not enough that I'm knocked up, I need your milt!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Your scaly cock is just what I need since I got pregnant!"
                ]
			},
            "novakid" : {
                "default" : [
					"It's almost too hot to touch, but my pregnant pussy needs to be filled~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Yes! Shoot me full of your hot gases! I'm already knocked up!"
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"female" : {
            "default" : {
                "default" : [
					"You know... unnnf~... he could get you pregnant, too, if you wanted...",
					"My pregnant ass is wet with your juice~!"
                ],
				"pregnant" : [
				"I can feel your belly against me!"
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
					"We should get pregnant together next time!"
				],
				"pregnant" : [
					"Which of our bellies is bigger?"
				],
				"climaxing" : [
					"You're drenching my thighs!"
				]
			},
			"avali" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
					"I get so horny when I'm pregnant! Does that happen to Avalis?"
				]
			},
            "avian" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"I get so horny when I'm pregnant! Does that happen to Avians?"
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "glitch" : {
                "default" : [
                ],
				"pregnant" : [
					"We're bigger in all the same places!"
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
					"Do you want him to get you pregnant next?"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
					"I'm already carrying babies, but your eggs feel so good!"
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		}
	},
	"climax" : {
		"default" : {
			"default" : {
				"default" : [
					"I'm gushing everywhere~~!",
					"Yesssss~~~~~! I'm Cominggg~!",
					"Ohmygodyes don't stop!"
				],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avali" : {
                "default" : [
					"Oh, I'm soaking your feathers!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "avian" : {
                "default" : [
					"Oh, I'm soaking your feathers!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "glitch" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
                ],
				"pregnant" : [
					"I'm coming all over your steaming belly!"
				],
                "climaxing" : [
					"It's like fucking in a sauna!"
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"male" : {
            "default" : {
                "default" : [
					"Yessss~! Your cock is so good~~ I'm cominggg~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
					"Oh yes, your ape cock is making me cum!"
				],
				"pregnant" : [
				],
				"climaxing" : [
					"Fill me up with your banana cream!"
				]
			},
			"avali" : {
				"default" : [
					"Your prey is cumming~!"
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avian" : {
                "default" : [
					"I want to lay your eggs!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "glitch" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		},
		"female" : {
            "default" : {
                "default" : [
					"I'm gushing all over your pussy~! Yesss~!",
					"Ohmygod Yes~! Keep doing that! I'm Cominggg~!"
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
			"apex" : {
				"default" : [
					"Your wet ape pussy is gushing!"
				],
				"pregnant" : [
					"Your hairy belly is so full!"
				],
				"climaxing" : [
					"Your wet ape pussy is gushing!"
				]
			},
			"avali" : {
				"default" : [
					"Oooh~~! Your cloaca is rubbing on my clit!"
				],
				"pregnant" : [
				],
				"climaxing" : [
				]
			},
            "avian" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "felin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "floran" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "glitch" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "human" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "hylotl" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			},
            "novakid" : {
                "default" : [
					"Your cock is red hot! Don't stop!!!~"
                ],
				"pregnant" : [
				],
                "climaxing" : [
					"Yes let's cum together, it's sizzling!"
                ]
			},
            "penguin" : {
                "default" : [
                ],
				"pregnant" : [
				],
                "climaxing" : [
                ]
			}
		}
	}
}]


default: You've got me from behind, I wonder how long you'll go at it~!

default: Ooh, I'm so horny all of the sudden~! Keep going~!

default: I've been so naughty! Punish me harder~!

default: My thighs are wet with your juices~! I feel so dirty!

pregnant: I can feel your pregnant belly against me! I didn't know that would make me so wet!~~

default: You've got me from behind, I wonder how long you can last~!

default: Are you going to empty your load inside me?

default: I'm so wet, you could slip it all the way into my asshole~~!

climaxing: O-oh~! You're cumming~! Unng, fill me up~!

climaxing: So much cum! Spray it inside me until it runs out!~

default:
O-oh~, your body is so hot against me!
Have you ever had a human boy?

pregnant:
Your belly is so hot on my skin!
Your glowing belly is so sexy!

default: What will... what will happen if you come inside me?

climaxing: Steam is coming out! ohhh it feels so good!!!~

climaxing: I hope you knocked me up! It feels so hot inside me!

default: I can feel your fat pussy rubbing on my ass!

default: You know how I like it, be rough with me~~!

climaxing: Your juice is everywhere! It feels so good!

climaxing: I'm softer than Apex girls.... I hope my pussy is enough for you!

default: Ohmygod! Human cocks aren't this thiiiiiick!

default: YESS! Stuff me full with your hairy cock!

climaxing: OH you're filling me up! Make me carry your little apes!

default: Do you always take your prey from behind~~!

climaxing: We've soaked your pretty feathers fucking me~~!

pregnant: You're so full of eggs, it makes me wet to think about!

climaxing: Oh you came already? Let me clean you up~~!

pregnant: It feels like a big litter in your belly~!!

default: I've never been this wet before, your nectar is driving me wild!

default: Your scent makes me... it makes me want your cock so badly...

climaxing: Your cum tingles! Is it going to make me pregnant?

default: Oooohh~ I didn't know you could do that~~!

default: Ohmygod! How do you fit me so perfectly? I'm going to c-c-c-cum!

climaxing: You're squirting your oil down my thighs!

default: I... I didn't know it could extend like thiiiiiisss!

climaxing: I hope that's more than just oil, I want you to knock me up~!

default: You're so soft and lovely. I've wanted you all day~~~~!

climaxing: You're soaking my asshole... you'd better lick that up!

default:
Fuck yeah, fill me up!
You're in me just right~!
Are you going to finish in me?

climaxing:
Oh god yes! Fill me to the brim!
YESSS! Keep cumminnnggggg!
Fill up my ass~~!

default: You're so slippery! I want to slide on top of you next~!

climaxing: Are you... are you putting eggs in me? Ohgod it feels so good... don't stop!

pregnant: I can feel your eggs moving around, you're so full!

default: Your rod is so slippery and thick! Can i taste it?

default: Your scales are hitting all the right places~~~~!

default: I'm ready to burst but I need this so bad~!

default: You know... unnnf~... he could get you pregnant, too, if you wanted...

default: My pregnant ass is wet with your juice~!

default: I'm already pregnant, but I can't get enough cum~!

climaxing:
Mmh~! Fill up my pregnant ass~!
Your cum is running down my thighs~~~!
Your hot cum is pouring out of me~!

default: It's almost too hot to touch, but my pregnant ass needs to be filled~!

climaxing: Yes! Shoot me full of your hot gases! I'm already knocked up!

default: We should get pregnant together next time!

default: I need a big ape to fill up my swollen asshole!

default: You can be rough with me, I'm not carrying eggs!

climaxing: Your feathers! I'm more ticklish now that I'm pregnant!!

pregnant: I get so horny when I'm pregnant! Does that happen to Avian?

default: Your hands feel so soft on my pregnant belly!

default: I get so wet when I'm pregnant... I need you to lap it up!

climaxing: Oh god, your claws are digging into me! It feels so good!

pregnant: I wish I could have... a big litter like yoursss~!

climaxing: Yessss! Please I want to be even more full!

default: ... even though I'm pregnant, I can't stop thinking about your nectar!

climaxing: Your petals feel so good against my pregnant ass!

pregnant: Since we got pregnant, your scent has become... intoxicating...

climaxing: This nectar is... so strong! I need more!

default: Yes! Spank my pregnant ass raw with your gears!

default: I want your soft hands all over my pregnant body!

default: Do you want me to get you pregnant next?

pregnant: It's so sexy that we're pregnant together!

default: Ohgod, your scales are rubbing just right! Don't stop!

climaxing: I'm already carrying babies, but your eggs feel so good!

default: It's not enough that I'm knocked up, I need your milt!

climaxing: Your scaly cock is just what I need since I got pregnant!

default:
I'm gushing everywhere~~!
Yesssss~~~~~! I'm Cominggg~!

default: Yessss~! Your cock is so good~~ I'm cominggg~!

default: I'm gushing all over your pussy~! Yesss~!

default: Ohmygod Yes~! Keep doing that! I'm Cominggg~!

pregnant: I'm coming all over your steaming belly!

repo_name: BottleBattalion/expanded

license: unknown


default: You're pulling me so tight~! Dig your nails into my scales, lover~!

default: What magnificent poise you demonstrate pumping into me~!

climaxing: Unng, tear into my scales, and inseminate my eggs, lover~!

default: Uunf. How uncouth your barbaric thrusts, yet oh so pleasurable. Mmnh~!

default: Ah~! Mmph~!... You exude such a delightful aroma~!

climaxing: Ahh~!... How can it be that such barbarism feels so good?~

climaxing: Uunh~!... You Florans are insatiable~!...

default: Your member feels so hard against my scales~!...

default: Ah~! The breeding efficiency of a machine~!...

climaxing: Ahh~! Wh- what is this you're injecting into me~?!

default: Mmnh~... Your soft member feels perfect against my scales~!

default: Uunf. Yes~!... Show me what mating is like on Earth~!

climaxing: Ahh~! Yes~! Use me to carry your Human DNA~!

climaxing: Aaahh~! D- Do all Humans carry so much semen~?

default: I- It's so hot~!... Ahn!~ You'll boil me alive~!

climaxing: Uhhnn~!... Ah~! Launch your shinining emissions into me~!

climaxing: A- Ahhh~!... Is this what Novakid semen feels like~?... So hot~!...

default: Ahn~! Yes~!... Let us breed together as animals do~!

default: Mmnh~! Your fur feels absolutely delightful against my scales~!

climaxing: Yes~! May our children all have such fur as yours~!

climaxing: O- Oh~! I feel it~! Release your Apex load inside of me~!

default: Ahh~! Yes!~ Dig your mighty talons into me~!

climaxing: Oooh~!... Yes~! May our children be blessed by your Kluex~!

default: Ummh~! Let us populate the stars with our noble blood~!

default: Ah!~ Yes!~ Fill my womb with beautiful Hylotl DNA~!

climaxing: Mmnh~... I can feel your Hylotl sperm swimming inside of me~!


default: Ah!~ Yes!~ Fill my rectum with beautiful Hylotl DNA~!


climaxing: Yee-haw~! Plant some seeds in my field pard'ner~! Let's create a spark of life~!


code:
[{--// Position: Butterfly. I am the one standing (Actor 1)
    "default" : {--This actor's state. Valid entries are: "default" (having sex), "pregnant" and "climaxing".
        "default" : {--The partner's gender. Valid entries (so far) are "male", "female" or "default" (Basically functions as a wildcard).
            "default" : {--The partner's race. Entries should be obvious; "human", "penguin", etc. Also accepts "default" as a wildcard.
                "default" : [--The partner's state. Same valid entries as first tag. Note: Dialogue for both actors climaxing at once can be tricky to appear in-game, but works.
                    "I am fucking a unspecified gender partner of an unspecified race in the X!"
                ],
                "climaxing" : [
                    "My unspecified gender partner of an unspecified race is cumming!"
                ],
				"pregnant" : [
					"My unspecified gender partner is pregnant!"
				]
			}
		},
		"male" : {
			"avali" : {
				"default" : [
					"I am fucking a male avali in the ass!"
				],
				"climaxing" : [
					"My avali male partner is cumming all over the floor!"
				]
			}
		}
	},
	"pregnant" : {
		"default" : {
			"default" : {
				"default" : [
					"I am fucking a unspecified gender partner of an unspecified race, and i am pregnant!"
				]
			}
		}
	}
},
{--// Position: Butterfly. I am the one being held. (Actor 2)
    "default" : {--This actor's state. Valid entries are: "default" (having sex), "pregnant" and "climaxing".
        "default" : {--The partner's gender. Valid entries (so far) are "male", "female" or "default" (Basically functions as a wildcard).
            "default" : {--The partner's race. Entries should be obvious; "human", "penguin", etc. Also accepts "default" as a wildcard.
                "default" : [--The partner's state. Same valid entries as first tag. Note: Dialogue for both actors climaxing at once can be tricky to appear in-game, but works.
                    "I am being fucked by a unspecified gender partner of an unspecified race in the X!"
                ],
                "climaxing" : [
                    "My unspecified gender partner of an unspecified race is cumming!"
                ],
				"pregnant" : [
					"My unspecified gender partner is pregnant!"
				]
			}
		},
		"male" : {
			"avali" : {
				"default" : [
					"I am being fucked by a male avali in the ass!"
				],
				"climaxing" : [
					"My avali male partner is cumming!"
				]
			}
		}
	},
	"pregnant" : {
		"default" : {
			"default" : {
				"default" : [
					"I am fucking a unspecified gender partner of an unspecified race, and i am pregnant!"
				]
			}
		}
	}
}]


code:
CC?=gcc
LD?=gcc
ifeq ($(OS), Windows_NT)
	UNAME:=Windows
else
	UNAME:=$(shell uname -s)
endif

ifeq ($(UNAME), Windows)
	CC=gcc
	LD=gcc
	exec_ext=.exe
	dyn_ext=.dll
endif

ifeq ($(UNAME), Linux)
	exec_ext=
	dyn_ext=.so
endif

CFLAGS=-Os -I../lua/src
LDFLAGS=-fPIC
files = puff pufflua
bins = pufflua53$(dyn_ext)

all: $(bins)

clean:
	rm *.o
	rm *$(dyn_ext)

pufflua53$(dyn_ext) : $(files:%=%.o)
	$(LD) -shared $(LDFLAGS) -o $@ $^ -L../lua/src -llua53

$(files:%=%.o) : %.o : %.c Makefile
	$(CC) $(CFLAGS) -c -o $@ $<

path: Makefile


code:
/*
 * puff.c
 * Copyright (C) 2002-2013 Mark Adler
 * For conditions of distribution and use, see copyright notice in puff.h
 * version 2.3, 21 Jan 2013
 *
 * puff.c is a simple inflate written to be an unambiguous way to specify the
 * deflate format.  It is not written for speed but rather simplicity.  As a
 * side benefit, this code might actually be useful when small code is more
 * important than speed, such as bootstrap applications.  For typical deflate
 * data, zlib's inflate() is about four times as fast as puff().  zlib's
 * inflate compiles to around 20K on my machine, whereas puff.c compiles to
 * around 4K on my machine (a PowerPC using GNU cc).  If the faster decode()
 * function here is used, then puff() is only twice as slow as zlib's
 * inflate().
 *
 * All dynamically allocated memory comes from the stack.  The stack required
 * is less than 2K bytes.  This code is compatible with 16-bit int's and
 * assumes that long's are at least 32 bits.  puff.c uses the short data type,
 * assumed to be 16 bits, for arrays in order to conserve memory.  The code
 * works whether integers are stored big endian or little endian.
 *
 * In the comments below are "Format notes" that describe the inflate process
 * and document some of the less obvious aspects of the format.  This source
 * code is meant to supplement RFC 1951, which formally describes the deflate
 * format:
 *
 *    http://www.zlib.org/rfc-deflate.html
 */

/*
 * Change history:
 *
 * 1.0  10 Feb 2002     - First version
 * 1.1  17 Feb 2002     - Clarifications of some comments and notes
 *                      - Update puff() dest and source pointers on negative
 *                        errors to facilitate debugging deflators
 *                      - Remove longest from struct huffman -- not needed
 *                      - Simplify offs[] index in construct()
 *                      - Add input size and checking, using longjmp() to
 *                        maintain easy readability
 *                      - Use short data type for large arrays
 *                      - Use pointers instead of long to specify source and
 *                        destination sizes to avoid arbitrary 4 GB limits
 * 1.2  17 Mar 2002     - Add faster version of decode(), doubles speed (!),
 *                        but leave simple version for readabilty
 *                      - Make sure invalid distances detected if pointers
 *                        are 16 bits
 *                      - Fix fixed codes table error
 *                      - Provide a scanning mode for determining size of
 *                        uncompressed data
 * 1.3  20 Mar 2002     - Go back to lengths for puff() parameters [Gailly]
 *                      - Add a puff.h file for the interface
 *                      - Add braces in puff() for else do [Gailly]
 *                      - Use indexes instead of pointers for readability
 * 1.4  31 Mar 2002     - Simplify construct() code set check
 *                      - Fix some comments
 *                      - Add FIXLCODES #define
 * 1.5   6 Apr 2002     - Minor comment fixes
 * 1.6   7 Aug 2002     - Minor format changes
 * 1.7   3 Mar 2003     - Added test code for distribution
 *                      - Added zlib-like license
 * 1.8   9 Jan 2004     - Added some comments on no distance codes case
 * 1.9  21 Feb 2008     - Fix bug on 16-bit integer architectures [Pohland]
 *                      - Catch missing end-of-block symbol error
 * 2.0  25 Jul 2008     - Add #define to permit distance too far back
 *                      - Add option in TEST code for puff to write the data
 *                      - Add option in TEST code to skip input bytes
 *                      - Allow TEST code to read from piped stdin
 * 2.1   4 Apr 2010     - Avoid variable initialization for happier compilers
 *                      - Avoid unsigned comparisons for even happier compilers
 * 2.2  25 Apr 2010     - Fix bug in variable initializations [Oberhumer]
 *                      - Add const where appropriate [Oberhumer]
 *                      - Split if's and ?'s for coverage testing
 *                      - Break out test code to separate file
 *                      - Move NIL to puff.h
 *                      - Allow incomplete code only if single code length is 1
 *                      - Add full code coverage test to Makefile
 * 2.3  21 Jan 2013     - Check for invalid code length codes in dynamic blocks
 */

#include <setjmp.h>             /* for setjmp(), longjmp(), and jmp_buf */
#include "puff.h"               /* prototype for puff() */

#define local static            /* for local function definitions */

/*
 * Maximums for allocations and loops.  It is not useful to change these --
 * they are fixed by the deflate format.
 */
#define MAXBITS 15              /* maximum bits in a code */
#define MAXLCODES 286           /* maximum number of literal/length codes */
#define MAXDCODES 30            /* maximum number of distance codes */
#define MAXCODES (MAXLCODES+MAXDCODES)  /* maximum codes lengths to read */
#define FIXLCODES 288           /* number of fixed literal/length codes */

/* input and output state */
struct state {
    /* output state */
    unsigned char *out;         /* output buffer */
    unsigned long outlen;       /* available space at out */
    unsigned long outcnt;       /* bytes written to out so far */

    /* input state */
    const unsigned char *in;    /* input buffer */
    unsigned long inlen;        /* available input at in */
    unsigned long incnt;        /* bytes read so far */
    int bitbuf;                 /* bit buffer */
    int bitcnt;                 /* number of bits in bit buffer */

    /* input limit error return state for bits() and decode() */
    jmp_buf env;
};

/*
 * Return need bits from the input stream.  This always leaves less than
 * eight bits in the buffer.  bits() works properly for need == 0.
 *
 * Format notes:
 *
 * - Bits are stored in bytes from the least significant bit to the most
 *   significant bit.  Therefore bits are dropped from the bottom of the bit
 *   buffer, using shift right, and new bytes are appended to the top of the
 *   bit buffer, using shift left.
 */
local int bits(struct state *s, int need)
{
    long val;           /* bit accumulator (can use up to 20 bits) */

    /* load at least need bits into val */
    val = s->bitbuf;
    while (s->bitcnt < need) {
        if (s->incnt == s->inlen)
            longjmp(s->env, 1);         /* out of input */
        val |= (long)(s->in[s->incnt++]) << s->bitcnt;  /* load eight bits */
        s->bitcnt += 8;
    }

    /* drop need bits and update buffer, always zero to seven bits left */
    s->bitbuf = (int)(val >> need);
    s->bitcnt -= need;

    /* return need bits, zeroing the bits above that */
    return (int)(val & ((1L << need) - 1));
}

/*
 * Process a stored block.
 *
 * Format notes:
 *
 * - After the two-bit stored block type (00), the stored block length and
 *   stored bytes are byte-aligned for fast copying.  Therefore any leftover
 *   bits in the byte that has the last bit of the type, as many as seven, are
 *   discarded.  The value of the discarded bits are not defined and should not
 *   be checked against any expectation.
 *
 * - The second inverted copy of the stored block length does not have to be
 *   checked, but it's probably a good idea to do so anyway.
 *
 * - A stored block can have zero length.  This is sometimes used to byte-align
 *   subsets of the compressed data for random access or partial recovery.
 */
local int stored(struct state *s)
{
    unsigned len;       /* length of stored block */

    /* discard leftover bits from current byte (assumes s->bitcnt < 8) */
    s->bitbuf = 0;
    s->bitcnt = 0;

    /* get length and check against its one's complement */
    if (s->incnt + 4 > s->inlen)
        return 2;                               /* not enough input */
    len = s->in[s->incnt++];
    len |= s->in[s->incnt++] << 8;
    if (s->in[s->incnt++] != (~len & 0xff) ||
        s->in[s->incnt++] != ((~len >> 8) & 0xff))
        return -2;                              /* didn't match complement! */

    /* copy len bytes from in to out */
    if (s->incnt + len > s->inlen)
        return 2;                               /* not enough input */
    if (s->out != NIL) {
        if (s->outcnt + len > s->outlen)
            return 1;                           /* not enough output space */
        while (len--)
            s->out[s->outcnt++] = s->in[s->incnt++];
    }
    else {                                      /* just scanning */
        s->outcnt += len;
        s->incnt += len;
    }

    /* done with a valid stored block */
    return 0;
}

/*
 * Huffman code decoding tables.  count[1..MAXBITS] is the number of symbols of
 * each length, which for a canonical code are stepped through in order.
 * symbol[] are the symbol values in canonical order, where the number of
 * entries is the sum of the counts in count[].  The decoding process can be
 * seen in the function decode() below.
 */
struct huffman {
    short *count;       /* number of symbols of each length */
    short *symbol;      /* canonically ordered symbols */
};

/*
 * Decode a code from the stream s using huffman table h.  Return the symbol or
 * a negative value if there is an error.  If all of the lengths are zero, i.e.
 * an empty code, or if the code is incomplete and an invalid code is received,
 * then -10 is returned after reading MAXBITS bits.
 *
 * Format notes:
 *
 * - The codes as stored in the compressed data are bit-reversed relative to
 *   a simple integer ordering of codes of the same lengths.  Hence below the
 *   bits are pulled from the compressed data one at a time and used to
 *   build the code value reversed from what is in the stream in order to
 *   permit simple integer comparisons for decoding.  A table-based decoding
 *   scheme (as used in zlib) does not need to do this reversal.
 *
 * - The first code for the shortest length is all zeros.  Subsequent codes of
 *   the same length are simply integer increments of the previous code.  When
 *   moving up a length, a zero bit is appended to the code.  For a complete
 *   code, the last code of the longest length will be all ones.
 *
 * - Incomplete codes are handled by this decoder, since they are permitted
 *   in the deflate format.  See the format notes for fixed() and dynamic().
 */
#ifdef SLOW
local int decode(struct state *s, const struct huffman *h)
{
    int len;            /* current number of bits in code */
    int code;           /* len bits being decoded */
    int first;          /* first code of length len */
    int count;          /* number of codes of length len */
    int index;          /* index of first code of length len in symbol table */

    code = first = index = 0;
    for (len = 1; len <= MAXBITS; len++) {
        code |= bits(s, 1);             /* get next bit */
        count = h->count[len];
        if (code - count < first)       /* if length len, return symbol */
            return h->symbol[index + (code - first)];
        index += count;                 /* else update for next length */
        first += count;
        first <<= 1;
        code <<= 1;
    }
    return -10;                         /* ran out of codes */
}

/*
 * A faster version of decode() for real applications of this code.   It's not
 * as readable, but it makes puff() twice as fast.  And it only makes the code
 * a few percent larger.
 */
#else /* !SLOW */
local int decode(struct state *s, const struct huffman *h)
{
    int len;            /* current number of bits in code */
    int code;           /* len bits being decoded */
    int first;          /* first code of length len */
    int count;          /* number of codes of length len */
    int index;          /* index of first code of length len in symbol table */
    int bitbuf;         /* bits from stream */
    int left;           /* bits left in next or left to process */
    short *next;        /* next number of codes */

    bitbuf = s->bitbuf;
    left = s->bitcnt;
    code = first = index = 0;
    len = 1;
    next = h->count + 1;
    while (1) {
        while (left--) {
            code |= bitbuf & 1;
            bitbuf >>= 1;
            count = *next++;
            if (code - count < first) { /* if length len, return symbol */
                s->bitbuf = bitbuf;
                s->bitcnt = (s->bitcnt - len) & 7;
                return h->symbol[index + (code - first)];
            }
            index += count;             /* else update for next length */
            first += count;
            first <<= 1;
            code <<= 1;
            len++;
        }
        left = (MAXBITS+1) - len;
        if (left == 0)
            break;
        if (s->incnt == s->inlen)
            longjmp(s->env, 1);         /* out of input */
        bitbuf = s->in[s->incnt++];
        if (left > 8)
            left = 8;
    }
    return -10;                         /* ran out of codes */
}
#endif /* SLOW */

/*
 * Given the list of code lengths length[0..n-1] representing a canonical
 * Huffman code for n symbols, construct the tables required to decode those
 * codes.  Those tables are the number of codes of each length, and the symbols
 * sorted by length, retaining their original order within each length.  The
 * return value is zero for a complete code set, negative for an over-
 * subscribed code set, and positive for an incomplete code set.  The tables
 * can be used if the return value is zero or positive, but they cannot be used
 * if the return value is negative.  If the return value is zero, it is not
 * possible for decode() using that table to return an error--any stream of
 * enough bits will resolve to a symbol.  If the return value is positive, then
 * it is possible for decode() using that table to return an error for received
 * codes past the end of the incomplete lengths.
 *
 * Not used by decode(), but used for error checking, h->count[0] is the number
 * of the n symbols not in the code.  So n - h->count[0] is the number of
 * codes.  This is useful for checking for incomplete codes that have more than
 * one symbol, which is an error in a dynamic block.
 *
 * Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS
 * This is assured by the construction of the length arrays in dynamic() and
 * fixed() and is not verified by construct().
 *
 * Format notes:
 *
 * - Permitted and expected examples of incomplete codes are one of the fixed
 *   codes and any code with a single symbol which in deflate is coded as one
 *   bit instead of zero bits.  See the format notes for fixed() and dynamic().
 *
 * - Within a given code length, the symbols are kept in ascending order for
 *   the code bits definition.
 */
local int construct(struct huffman *h, const short *length, int n)
{
    int symbol;         /* current symbol when stepping through length[] */
    int len;            /* current length when stepping through h->count[] */
    int left;           /* number of possible codes left of current length */
    short offs[MAXBITS+1];      /* offsets in symbol table for each length */

    /* count number of codes of each length */
    for (len = 0; len <= MAXBITS; len++)
        h->count[len] = 0;
    for (symbol = 0; symbol < n; symbol++)
        (h->count[length[symbol]])++;   /* assumes lengths are within bounds */
    if (h->count[0] == n)               /* no codes! */
        return 0;                       /* complete, but decode() will fail */

    /* check for an over-subscribed or incomplete set of lengths */
    left = 1;                           /* one possible code of zero length */
    for (len = 1; len <= MAXBITS; len++) {
        left <<= 1;                     /* one more bit, double codes left */
        left -= h->count[len];          /* deduct count from possible codes */
        if (left < 0)
            return left;                /* over-subscribed--return negative */
    }                                   /* left > 0 means incomplete */

    /* generate offsets into symbol table for each length for sorting */
    offs[1] = 0;
    for (len = 1; len < MAXBITS; len++)
        offs[len + 1] = offs[len] + h->count[len];

    /*
     * put symbols in table sorted by length, by symbol order within each
     * length
     */
    for (symbol = 0; symbol < n; symbol++)
        if (length[symbol] != 0)
            h->symbol[offs[length[symbol]]++] = symbol;

    /* return zero for complete set, positive for incomplete set */
    return left;
}

/*
 * Decode literal/length and distance codes until an end-of-block code.
 *
 * Format notes:
 *
 * - Compressed data that is after the block type if fixed or after the code
 *   description if dynamic is a combination of literals and length/distance
 *   pairs terminated by and end-of-block code.  Literals are simply Huffman
 *   coded bytes.  A length/distance pair is a coded length followed by a
 *   coded distance to represent a string that occurs earlier in the
 *   uncompressed data that occurs again at the current location.
 *
 * - Literals, lengths, and the end-of-block code are combined into a single
 *   code of up to 286 symbols.  They are 256 literals (0..255), 29 length
 *   symbols (257..285), and the end-of-block symbol (256).
 *
 * - There are 256 possible lengths (3..258), and so 29 symbols are not enough
 *   to represent all of those.  Lengths 3..10 and 258 are in fact represented
 *   by just a length symbol.  Lengths 11..257 are represented as a symbol and
 *   some number of extra bits that are added as an integer to the base length
 *   of the length symbol.  The number of extra bits is determined by the base
 *   length symbol.  These are in the static arrays below, lens[] for the base
 *   lengths and lext[] for the corresponding number of extra bits.
 *
 * - The reason that 258 gets its own symbol is that the longest length is used
 *   often in highly redundant files.  Note that 258 can also be coded as the
 *   base value 227 plus the maximum extra value of 31.  While a good deflate
 *   should never do this, it is not an error, and should be decoded properly.
 *
 * - If a length is decoded, including its extra bits if any, then it is
 *   followed a distance code.  There are up to 30 distance symbols.  Again
 *   there are many more possible distances (1..32768), so extra bits are added
 *   to a base value represented by the symbol.  The distances 1..4 get their
 *   own symbol, but the rest require extra bits.  The base distances and
 *   corresponding number of extra bits are below in the static arrays dist[]
 *   and dext[].
 *
 * - Literal bytes are simply written to the output.  A length/distance pair is
 *   an instruction to copy previously uncompressed bytes to the output.  The
 *   copy is from distance bytes back in the output stream, copying for length
 *   bytes.
 *
 * - Distances pointing before the beginning of the output data are not
 *   permitted.
 *
 * - Overlapped copies, where the length is greater than the distance, are
 *   allowed and common.  For example, a distance of one and a length of 258
 *   simply copies the last byte 258 times.  A distance of four and a length of
 *   twelve copies the last four bytes three times.  A simple forward copy
 *   ignoring whether the length is greater than the distance or not implements
 *   this correctly.  You should not use memcpy() since its behavior is not
 *   defined for overlapped arrays.  You should not use memmove() or bcopy()
 *   since though their behavior -is- defined for overlapping arrays, it is
 *   defined to do the wrong thing in this case.
 */
local int codes(struct state *s,
                const struct huffman *lencode,
                const struct huffman *distcode)
{
    int symbol;         /* decoded symbol */
    int len;            /* length for copy */
    unsigned dist;      /* distance for copy */
    static const short lens[29] = { /* Size base for length codes 257..285 */
        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
    static const short lext[29] = { /* Extra bits for length codes 257..285 */
        0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
        3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
    static const short dists[30] = { /* Offset base for distance codes 0..29 */
        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
        8193, 12289, 16385, 24577};
    static const short dext[30] = { /* Extra bits for distance codes 0..29 */
        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
        12, 12, 13, 13};

    /* decode literals and length/distance pairs */
    do {
        symbol = decode(s, lencode);
        if (symbol < 0)
            return symbol;              /* invalid symbol */
        if (symbol < 256) {             /* literal: symbol is the byte */
            /* write out the literal */
            if (s->out != NIL) {
                if (s->outcnt == s->outlen)
                    return 1;
                s->out[s->outcnt] = symbol;
            }
            s->outcnt++;
        }
        else if (symbol > 256) {        /* length */
            /* get and compute length */
            symbol -= 257;
            if (symbol >= 29)
                return -10;             /* invalid fixed code */
            len = lens[symbol] + bits(s, lext[symbol]);

            /* get and check distance */
            symbol = decode(s, distcode);
            if (symbol < 0)
                return symbol;          /* invalid symbol */
            dist = dists[symbol] + bits(s, dext[symbol]);
#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
            if (dist > s->outcnt)
                return -11;     /* distance too far back */
#endif

            /* copy length bytes from distance bytes back */
            if (s->out != NIL) {
                if (s->outcnt + len > s->outlen)
                    return 1;
                while (len--) {
                    s->out[s->outcnt] =
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
                        dist > s->outcnt ?
                            0 :
#endif
                            s->out[s->outcnt - dist];
                    s->outcnt++;
                }
            }
            else
                s->outcnt += len;
        }
    } while (symbol != 256);            /* end of block symbol */

    /* done with a valid fixed or dynamic block */
    return 0;
}

/*
 * Process a fixed codes block.
 *
 * Format notes:
 *
 * - This block type can be useful for compressing small amounts of data for
 *   which the size of the code descriptions in a dynamic block exceeds the
 *   benefit of custom codes for that block.  For fixed codes, no bits are
 *   spent on code descriptions.  Instead the code lengths for literal/length
 *   codes and distance codes are fixed.  The specific lengths for each symbol
 *   can be seen in the "for" loops below.
 *
 * - The literal/length code is complete, but has two symbols that are invalid
 *   and should result in an error if received.  This cannot be implemented
 *   simply as an incomplete code since those two symbols are in the "middle"
 *   of the code.  They are eight bits long and the longest literal/length\
 *   code is nine bits.  Therefore the code must be constructed with those
 *   symbols, and the invalid symbols must be detected after decoding.
 *
 * - The fixed distance codes also have two invalid symbols that should result
 *   in an error if received.  Since all of the distance codes are the same
 *   length, this can be implemented as an incomplete code.  Then the invalid
 *   codes are detected while decoding.
 */
local int fixed(struct state *s)
{
    static int virgin = 1;
    static short lencnt[MAXBITS+1], lensym[FIXLCODES];
    static short distcnt[MAXBITS+1], distsym[MAXDCODES];
    static struct huffman lencode, distcode;

    /* build fixed huffman tables if first call (may not be thread safe) */
    if (virgin) {
        int symbol;
        short lengths[FIXLCODES];

        /* construct lencode and distcode */
        lencode.count = lencnt;
        lencode.symbol = lensym;
        distcode.count = distcnt;
        distcode.symbol = distsym;

        /* literal/length table */
        for (symbol = 0; symbol < 144; symbol++)
            lengths[symbol] = 8;
        for (; symbol < 256; symbol++)
            lengths[symbol] = 9;
        for (; symbol < 280; symbol++)
            lengths[symbol] = 7;
        for (; symbol < FIXLCODES; symbol++)
            lengths[symbol] = 8;
        construct(&lencode, lengths, FIXLCODES);

        /* distance table */
        for (symbol = 0; symbol < MAXDCODES; symbol++)
            lengths[symbol] = 5;
        construct(&distcode, lengths, MAXDCODES);

        /* do this just once */
        virgin = 0;
    }

    /* decode data until end-of-block code */
    return codes(s, &lencode, &distcode);
}

/*
 * Process a dynamic codes block.
 *
 * Format notes:
 *
 * - A dynamic block starts with a description of the literal/length and
 *   distance codes for that block.  New dynamic blocks allow the compressor to
 *   rapidly adapt to changing data with new codes optimized for that data.
 *
 * - The codes used by the deflate format are "canonical", which means that
 *   the actual bits of the codes are generated in an unambiguous way simply
 *   from the number of bits in each code.  Therefore the code descriptions
 *   are simply a list of code lengths for each symbol.
 *
 * - The code lengths are stored in order for the symbols, so lengths are
 *   provided for each of the literal/length symbols, and for each of the
 *   distance symbols.
 *
 * - If a symbol is not used in the block, this is represented by a zero as
 *   as the code length.  This does not mean a zero-length code, but rather
 *   that no code should be created for this symbol.  There is no way in the
 *   deflate format to represent a zero-length code.
 *
 * - The maximum number of bits in a code is 15, so the possible lengths for
 *   any code are 1..15.
 *
 * - The fact that a length of zero is not permitted for a code has an
 *   interesting consequence.  Normally if only one symbol is used for a given
 *   code, then in fact that code could be represented with zero bits.  However
 *   in deflate, that code has to be at least one bit.  So for example, if
 *   only a single distance base symbol appears in a block, then it will be
 *   represented by a single code of length one, in particular one 0 bit.  This
 *   is an incomplete code, since if a 1 bit is received, it has no meaning,
 *   and should result in an error.  So incomplete distance codes of one symbol
 *   should be permitted, and the receipt of invalid codes should be handled.
 *
 * - It is also possible to have a single literal/length code, but that code
 *   must be the end-of-block code, since every dynamic block has one.  This
 *   is not the most efficient way to create an empty block (an empty fixed
 *   block is fewer bits), but it is allowed by the format.  So incomplete
 *   literal/length codes of one symbol should also be permitted.
 *
 * - If there are only literal codes and no lengths, then there are no distance
 *   codes.  This is represented by one distance code with zero bits.
 *
 * - The list of up to 286 length/literal lengths and up to 30 distance lengths
 *   are themselves compressed using Huffman codes and run-length encoding.  In
 *   the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
 *   that length, and the symbols 16, 17, and 18 are run-length instructions.
 *   Each of 16, 17, and 18 are follwed by extra bits to define the length of
 *   the run.  16 copies the last length 3 to 6 times.  17 represents 3 to 10
 *   zero lengths, and 18 represents 11 to 138 zero lengths.  Unused symbols
 *   are common, hence the special coding for zero lengths.
 *
 * - The symbols for 0..18 are Huffman coded, and so that code must be
 *   described first.  This is simply a sequence of up to 19 three-bit values
 *   representing no code (0) or the code length for that symbol (1..7).
 *
 * - A dynamic block starts with three fixed-size counts from which is computed
 *   the number of literal/length code lengths, the number of distance code
 *   lengths, and the number of code length code lengths (ok, you come up with
 *   a better name!) in the code descriptions.  For the literal/length and
 *   distance codes, lengths after those provided are considered zero, i.e. no
 *   code.  The code length code lengths are received in a permuted order (see
 *   the order[] array below) to make a short code length code length list more
 *   likely.  As it turns out, very short and very long codes are less likely
 *   to be seen in a dynamic code description, hence what may appear initially
 *   to be a peculiar ordering.
 *
 * - Given the number of literal/length code lengths (nlen) and distance code
 *   lengths (ndist), then they are treated as one long list of nlen + ndist
 *   code lengths.  Therefore run-length coding can and often does cross the
 *   boundary between the two sets of lengths.
 *
 * - So to summarize, the code description at the start of a dynamic block is
 *   three counts for the number of code lengths for the literal/length codes,
 *   the distance codes, and the code length codes.  This is followed by the
 *   code length code lengths, three bits each.  This is used to construct the
 *   code length code which is used to read the remainder of the lengths.  Then
 *   the literal/length code lengths and distance lengths are read as a single
 *   set of lengths using the code length codes.  Codes are constructed from
 *   the resulting two sets of lengths, and then finally you can start
 *   decoding actual compressed data in the block.
 *
 * - For reference, a "typical" size for the code description in a dynamic
 *   block is around 80 bytes.
 */
local int dynamic(struct state *s)
{
    int nlen, ndist, ncode;             /* number of lengths in descriptor */
    int index;                          /* index of lengths[] */
    int err;                            /* construct() return value */
    short lengths[MAXCODES];            /* descriptor code lengths */
    short lencnt[MAXBITS+1], lensym[MAXLCODES];         /* lencode memory */
    short distcnt[MAXBITS+1], distsym[MAXDCODES];       /* distcode memory */
    struct huffman lencode, distcode;   /* length and distance codes */
    static const short order[19] =      /* permutation of code length codes */
        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

    /* construct lencode and distcode */
    lencode.count = lencnt;
    lencode.symbol = lensym;
    distcode.count = distcnt;
    distcode.symbol = distsym;

    /* get number of lengths in each table, check lengths */
    nlen = bits(s, 5) + 257;
    ndist = bits(s, 5) + 1;
    ncode = bits(s, 4) + 4;
    if (nlen > MAXLCODES || ndist > MAXDCODES)
        return -3;                      /* bad counts */

    /* read code length code lengths (really), missing lengths are zero */
    for (index = 0; index < ncode; index++)
        lengths[order[index]] = bits(s, 3);
    for (; index < 19; index++)
        lengths[order[index]] = 0;

    /* build huffman table for code lengths codes (use lencode temporarily) */
    err = construct(&lencode, lengths, 19);
    if (err != 0)               /* require complete code set here */
        return -4;

    /* read length/literal and distance code length tables */
    index = 0;
    while (index < nlen + ndist) {
        int symbol;             /* decoded value */
        int len;                /* last length to repeat */

        symbol = decode(s, &lencode);
        if (symbol < 0)
            return symbol;          /* invalid symbol */
        if (symbol < 16)                /* length in 0..15 */
            lengths[index++] = symbol;
        else {                          /* repeat instruction */
            len = 0;                    /* assume repeating zeros */
            if (symbol == 16) {         /* repeat last length 3..6 times */
                if (index == 0)
                    return -5;          /* no last length! */
                len = lengths[index - 1];       /* last length */
                symbol = 3 + bits(s, 2);
            }
            else if (symbol == 17)      /* repeat zero 3..10 times */
                symbol = 3 + bits(s, 3);
            else                        /* == 18, repeat zero 11..138 times */
                symbol = 11 + bits(s, 7);
            if (index + symbol > nlen + ndist)
                return -6;              /* too many lengths! */
            while (symbol--)            /* repeat last or zero symbol times */
                lengths[index++] = len;
        }
    }

    /* check for end-of-block code -- there better be one! */
    if (lengths[256] == 0)
        return -9;

    /* build huffman table for literal/length codes */
    err = construct(&lencode, lengths, nlen);
    if (err && (err < 0 || nlen != lencode.count[0] + lencode.count[1]))
        return -7;      /* incomplete code ok only for single length 1 code */

    /* build huffman table for distance codes */
    err = construct(&distcode, lengths + nlen, ndist);
    if (err && (err < 0 || ndist != distcode.count[0] + distcode.count[1]))
        return -8;      /* incomplete code ok only for single length 1 code */

    /* decode data until end-of-block code */
    return codes(s, &lencode, &distcode);
}

/*
 * Inflate source to dest.  On return, destlen and sourcelen are updated to the
 * size of the uncompressed data and the size of the deflate data respectively.
 * On success, the return value of puff() is zero.  If there is an error in the
 * source data, i.e. it is not in the deflate format, then a negative value is
 * returned.  If there is not enough input available or there is not enough
 * output space, then a positive error is returned.  In that case, destlen and
 * sourcelen are not updated to facilitate retrying from the beginning with the
 * provision of more input data or more output space.  In the case of invalid
 * inflate data (a negative error), the dest and source pointers are updated to
 * facilitate the debugging of deflators.
 *
 * puff() also has a mode to determine the size of the uncompressed output with
 * no output written.  For this dest must be (unsigned char *)0.  In this case,
 * the input value of *destlen is ignored, and on return *destlen is set to the
 * size of the uncompressed output.
 *
 * The return codes are:
 *
 *   2:  available inflate data did not terminate
 *   1:  output space exhausted before completing inflate
 *   0:  successful inflate
 *  -1:  invalid block type (type == 3)
 *  -2:  stored block length did not match one's complement
 *  -3:  dynamic block code description: too many length or distance codes
 *  -4:  dynamic block code description: code lengths codes incomplete
 *  -5:  dynamic block code description: repeat lengths with no first length
 *  -6:  dynamic block code description: repeat more than specified lengths
 *  -7:  dynamic block code description: invalid literal/length code lengths
 *  -8:  dynamic block code description: invalid distance code lengths
 *  -9:  dynamic block code description: missing end-of-block code
 * -10:  invalid literal/length or distance code in fixed or dynamic block
 * -11:  distance is too far back in fixed or dynamic block
 *
 * Format notes:
 *
 * - Three bits are read for each block to determine the kind of block and
 *   whether or not it is the last block.  Then the block is decoded and the
 *   process repeated if it was not the last block.
 *
 * - The leftover bits in the last byte of the deflate data after the last
 *   block (if it was a fixed or dynamic block) are undefined and have no
 *   expected values to check.
 */
int puff(unsigned char *dest,           /* pointer to destination pointer */
         unsigned long *destlen,        /* amount of output space */
         const unsigned char *source,   /* pointer to source data pointer */
         unsigned long *sourcelen)      /* amount of input available */
{
    struct state s;             /* input/output state */
    int last, type;             /* block information */
    int err;                    /* return value */

    /* initialize output state */
    s.out = dest;
    s.outlen = *destlen;                /* ignored if dest is NIL */
    s.outcnt = 0;

    /* initialize input state */
    s.in = source;
    s.inlen = *sourcelen;
    s.incnt = 0;
    s.bitbuf = 0;
    s.bitcnt = 0;

    /* return if bits() or decode() tries to read past available input */
    if (setjmp(s.env) != 0)             /* if came back here via longjmp() */
        err = 2;                        /* then skip do-loop, return error */
    else {
        /* process blocks until last block or error */
        do {
            last = bits(&s, 1);         /* one if last block */
            type = bits(&s, 2);         /* block type 0..3 */
            err = type == 0 ?
                    stored(&s) :
                    (type == 1 ?
                        fixed(&s) :
                        (type == 2 ?
                            dynamic(&s) :
                            -1));       /* type == 3, invalid */
            if (err != 0)
                break;                  /* return with error */
        } while (!last);
    }

    /* update the lengths and return */
    if (err <= 0) {
        *destlen = s.outcnt;
        *sourcelen = s.incnt;
    }
    return err;
}


code:
/* puff.h
  Copyright (C) 2002-2013 Mark Adler, all rights reserved
  version 2.3, 21 Jan 2013
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the author be held liable for any damages
  arising from the use of this software.
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
  Mark Adler    madler@alumni.caltech.edu
 */

/*
 * See puff.c for purpose and usage.
 */
#ifndef NIL
#  define NIL ((unsigned char *)0)      /* for no output option */
#endif

int puff(unsigned char *dest,           /* pointer to destination pointer */
         unsigned long *destlen,        /* amount of output space */
         const unsigned char *source,   /* pointer to source data pointer */
unsigned long *sourcelen); /* amount of input available */


code:
#define LUA_LIB
#include <lua.h>
#include <lauxlib.h>
#include "puff.h"

#define lerr(a) lua_pushstring(L,a); lua_error(L);

//puff(string data,expected_output_length)
int lpuff(lua_State *L){
	if(lua_isnil(L,-1)){
		lerr("puff() requires the expected output length");
	}
	long unsigned exp_len = lua_tonumber(L,-1) + 1;
	size_t inputsize;
	const char *str = lua_tolstring(L,-2,&inputsize);
	if(str == NULL){
		lerr("puff() Unable to get string for argument #1");
	}
	char output[exp_len];
	output[exp_len - 1] = '\0';
	unsigned long dummy;
	int err = puff(output,&exp_len,str,&inputsize);
	switch(err){
	case 2:
		lerr("available inflate data did not terminate");
		break;
	case 1:
		lerr("output space exhausted before completing inflate");
		break;
	case 0: //success
		break;
	case -1:
		lerr("invalid block type (type == 3)");
		break;
	case -2:
		lerr("stored block length did not match one's complement");
		break;
	case -3:
		lerr("dynamic block code description: too many length or distance codes");
		break;
	case -4:
		lerr("dynamic block code description: code lengths codes incomplete");
		break;
	case -5:
		lerr("dynamic block code description: repeat lengths with no first length");
		break;
	case -6:
		lerr("dynamic block code description: repeat more than specified lengths");
		break;
	case -7:
		lerr("dynamic block code description: invalid literal/length code lengths");
		break;
	case -8:
		lerr("dynamic block code description: invalid distance code lengths");
		break;
	case -9:
		lerr("dynamic block code description: missing end-of-block code");
		break;
	case -10:
		lerr("invalid literal/length or distance code in fixed or dynamic block");
		break;
	case -11:
		lerr("distance is too far back in fixed or dynamic block");
		break;
	default:
		lerr("An unknown error occured");
	}
	lua_pushstring(L,output);
	return 1;
}

int luaopen_pufflua(lua_State *L){
	lua_newtable(L);
	lua_pushcfunction(L,lpuff);
	lua_setfield(L,-2,"puff");
	return 1;
}


code:
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
*.swp
*.swo

# C extensions
*.so

# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*,cover
.hypothesis/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# IPython Notebook
.ipynb_checkpoints

# pyenv
.python-version

# celery beat schedule file
celerybeat-schedule

# dotenv
.env

# virtualenv
venv/
ENV/

# Spyder project settings
.spyderproject

# Rope project settings
.ropeproject

# Start.tw
src/config/start.tw

repo_name: Drosil/fc

path: .gitignore

license: mit


code:
further development:
-specialized slave schools
-fortifications
-more levels for militia edict (further militarize society)
-conquering other arcologies?

Events:
-famous criminal escapes to the arcology, followed by another arcology police force

Bugs:
-sometimes troop counts breaks
-sometimes rebel numbers have fractionary parts


code:
# How to vector art

Please read the whole document before starting to work.
Some aspects are not obvious right away.

Note: This does not actually describe how to be an artist.

## TL;DR

    killall inkscape
    artTools/vector_layer_split.py artTools/vector_source.svg tw src/art/vector/layers/
    compile

## 1. Be an artist

Make changes to the vector_source.svg.
Inkscape was thoroughly tested.
Adobe Illustrator might work decently, too.

## 2. Respect the structure

While editing, keep the Layers in mind.

* In Inkscape, Layers are special "Inkscape groups".
* In Illustrator, Layers are groups with user-definded IDs.
* All Layers should have an ID that is globally unique
  (not just within their subtree).

* Please use anonymous groups only for the ease of editing. Remove all "helper" groups before finally saving the file.
* Anonymous groups can be used for continous scaling (of e.g. boobs).

* Every asset that should go into a separate file needs to be in a labelled group
  (even if that is a group with only one shape).
* There are some globally available styles defined as CSS classes (e.g. skin, hair).
  Use them if your asset should be changed upon display.
  Do not set the style directly in the object.

## 3. Fix the document (before commiting, Inkscape only)

Inkscape shows weird behaviour in some regards.
If you use Inkscape, close the document and run

    python3 inkscape_svg_fixup.py vector_source.svg

before continuing. Open the file in Inkscape and save it again.
You need to make a minor change, as Inkscape will not save a unchanged file
(move the notes back and forth or something). The fixup does not produce
the same linebreaks as Inkscape or Illustrator and git will go mad because
the whole seems to have changed.

What it does:
* Adobe Illustrator uses group IDs as layer labels.
  Inkscape however uses layer labels and a separate, auto-generated group ID.
  inkscape_svg_fixup.py overwrites the group ID with the Inkscape layer label
  so they are synchronised with Inkscape layer labels.
* Inkscape copies the global style definition into the object *every time*
  the object is edited. If an object references a CSS class AND at the same time
  has a local style, the local style is removed
  so global dynamic styling is possible later on.

Note: Behaviour of Adobe Illustrator is untested.

## 4. Split the layers

Execute

    python3 vector_layer_split.py vector_source.svg tw ../src/art/vector/layers/

For revamped art

	python3 vector_revamp_layer_split.py vector_revamp_source.svg tw ../src/art/vector_revamp/layers/

. This application reads all groups in `vector_source.svg`.
Each group is stored in a separate file in the target directory `/src/art/vector/layers/`.
The group ID sets the file name. Therefore, the group ID **must not** contain spaces or any other weird characters.

Also consider:
* A group with ID ending in _ is ignored. Use Layers ending in _ to keep overview.
* A group with ID starting with "g" (Inkscape) or "XMLID" (Illustrator) is also ignored.
* Existing files are overwritten **without enquiry**.
* The target directory is not emptied. If a file is no longer needed, you should remove it manually.
* This procedure removes global definitions. This means, SVG filters are currently not supported.

Available output formats are `svg` and `tw`.
`svg` output exists for debug reasons.
`tw` embeds the SVG data into Twine files, but removes the global style definitions so they can be set during display.

## 5. Edit the code

`/src/art/` contains Twine code which shows the assets in the story.
There are many helpful comments in `/src/art/artWidgets.tw`.
The code also generates the previously removed global style definitions on the fly and per display.

## 6. Compile the story

Use the provided compile script (Windows batch or shell) for compiling.

## 7. Advanced usage

You can define multiple CSS classes to one element, e.g. "skin torso". When procedurally generating CSS, you can then set a global "skin" style, and a different one for "torso".

You can put variable text into the image using single quotes, e.g. "'+_tattooText+'". The single quotes *break* the quoting in Twine so the content of the Twine variable `_tattooText` is shown upon display. You can even align text on paths.

An anonymous group can be used for dynamic transformation. However, finding the correct parameters for the affine transformation matrix can be cumbersome. Use any method you see fit. See `src/art/vector/Boob.tw` for one example of the result.


code:
#!/usr/bin/env python3

'''
Application for "fixing" SVGs edited with Inkscape

These problems are addressed:

* Inkscape notoriously copies class styles into the object definitions.
https://bugs.launchpad.net/inkscape/+bug/167937

* Inkscape uses labels on layers. Layers are basically named groups.
  Inkscape does not sync the group id with the layer label.

Usage Example:
python3 inkscape_svg_fixup.py vector_source.svg

Note:
The output of lxml differs greatly from standard SVG indentation.
Please open and save the file in Inkscape before committing.
'''

import lxml.etree as etree
import sys

def fix(tree):
  # know namespaces
  ns = {
    'svg' : 'http://www.w3.org/2000/svg',
    'inkscape' : 'http://www.inkscape.org/namespaces/inkscape'
  }

  # find document global style definition
  # mangle it and interpret as python dictionary
  style_element = tree.find('./svg:style',namespaces=ns)
  style_definitions = style_element.text
  pythonic_style_definitions = '{'+style_definitions.\
  replace('\t.','"').replace('{','":"').replace('}','",').\
  replace('/*','#')+'}'
  styles = eval(pythonic_style_definitions)

  # go through all SVG elements
  for elem in tree.iter():
    if (elem.tag == etree.QName(ns['svg'], 'g')):
      # compare inkscape label with group element ID
      l = elem.get(etree.QName(ns['inkscape'], 'label'))
      if l:
        i = elem.get('id')
        if (i != l):
          print("Overwriting ID %s with Label %s..."%(i, l))
          elem.set('id', l)

    # remove all offending style attributes
    s = elem.get('style')
    c = elem.get('class')
    if (c and s):
      s = s.lower()
      c = c.split(' ')[0] # regard main style only
      cs = ''
      if c in styles:
        cs = styles[c].strip('; ').lower()
      if (c not in styles):
        print("Object id %s references unknown style class %s."%(i,c))
      else:
        if (cs != s.strip('; ')):
          print("Style %s removed from object id %s differed from class %s style %s."%(s,i,c,cs))
        del elem.attrib["style"]

if __name__ == "__main__":
  input_file = sys.argv[1]
  tree = etree.parse(input_file)
  fix(tree)
  # store SVG into file (input file is overwritten)
  svg = etree.tostring(tree, pretty_print=True)
  with open(input_file, 'wb') as f:
    f.write('<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n'.encode("utf-8"))
    f.write(svg)