Compile time evaluation #57

AvdLee · 2022-07-23T08:42:41Z

I was wondering whether you have any insights into compile-time optimization. Since the created files can be in numbers, compile times can add up quite a bit.

I'm thinking out loud here, but things to consider:

Are build times faster using a single file vs. the separated file's mode?
Extending a namespace, e.g. enum APIEndpoint, might be less performant than making individual instances conforming to a protocol APIEndpoint

I also wonder what the effect is to export binary size. Dead code stripping might be less successful when we're extending an enum APIEndpoint (based on a Paths configuration of namespace: "APIEndpoint") compared to making the code compilation work with protocol conformance.

Curious to hear your thoughts!

The text was updated successfully, but these errors were encountered:

kean · 2022-07-23T15:08:31Z

Are build times faster using a single file vs. the separated file's mode?

I've done a few tests in that area. Putting everything in a single file destroyed the performance (unexpectedly). Enabling WMO also did.

I heard about extensions being slow but haven't seen anything that confirms that theory.

liamnichols · 2022-07-25T08:00:28Z

Very interesting. I think there is certainly some room to write some documentation with advice on this. Specifically for larger schemas where this matters a lot more.

Another example is that we also chose to make our generated entities classes because using structs was massively bloating our binary.

I haven't looked, but since CreateAPI can generate compilable Swift Packages (use --package instead of --module), we could run some simple benchmarking on our test fixture packages (we already make sure that they all compile)...

Are there any existing tools out there that benchmark a SPM package already? I'm thinking the compilation time as well as the output binary size?

AvdLee · 2022-07-26T11:31:54Z

Compilation time and binary size are the two I worry about the most. I can see that my https://github.com/AvdLee/appstoreconnect-swift-sdk comes with slower build performance and large output archives.

It might also be interesting to see how dead-code removal build setting would affect outcomes, since it's often that implementors only use parts of the API in their client code (sparking ideas here!)

liamnichols · 2022-07-26T19:10:16Z

I wanted to have a quick look at the compile time with Xcode 14's new build timeline and just like @kean mentioned, it seems like single files are massively inefficient:

Single File	Split

It looks like the build system will parallelise based on file, not type, which I guess makes sense. I did a sense check on a community Slack and that seems to be the general consensus, so maybe with that it might be better for CreateAPI to focus on splitting by default, and possibly even removing the single-file option?

I know that there are a few small bugs caused by supporting the two different approaches already (i.e I can't compile the ASC generated code using a single file + operations style paths and I can't set operationId's on split operations style paths) so maybe this would help to simplify our efforts?

As for the issue in general, I had a play around with various different configurations in some informal tests and while I could make some differences...

I used the App Store Connect schema from your repo along with your base settings to generate a complete package (not just a module) and then compiled it in release mode (swift build -c release) as a dynamic library. Below are the sizes of the output dylib:

File Structure	Entity Type	Path Style	CodingKeys enums	Size
Split	Class	Operations	Yes	118.1MB
Merged	Class	Operations	Yes	N/A
Split	Class	REST	Yes	120.6MB
Merged	Class	REST	Yes	114.2MB
Split	Struct	REST	Yes	128.9MB
Merged	Struct	REST	Yes	120.6MB
Split	Class	Operations	No	73.8MB

I guess the most interesting discovery that I made part way through was that setting isGeneratingCustomCodingKeys to false massively reduces the binary size because we trade 341 CodingKey enums for a single struct.

I'm not quite sure why Splitting and Merging files has a difference on the overall binary size though? Maybe the release configuration is still including some debug information of some kind? Not sure how I'd figure out what has changed here.

I also wonder if it makes sense to keep other suboptimal options such as isGeneratingCustomCodingKeys? At the very minimum we could consider changing the default value, but it might even be easier to just drop the option?

It might also be interesting to see how dead-code removal build setting would affect outcomes, since it's often that implementors only use parts of the API in their client code (sparking ideas here!)

This is another good point. We already have include and exclude options for both Paths and Endpoints, but we found that they weren't very good since it's very hard to manually figure out the dependency graph so having to manually include a type and all of its dependant types is quite tiresome. There is however probably room to infer the required types based on just the paths that being generated which could help significantly.

AvdLee · 2022-07-28T09:18:23Z

These are some great insights, I love how you approached this! I'll play around with your story and see whether I can find some good results as well 💯

kean · 2022-07-28T12:42:48Z

That's fantastic, thanks for the insights, @liamnichols! And I love how in the new Xcode you can see the build graph.

Focus on splitting by default, and possibly even removing the single-file option?

It absolutely must. I can't think of scenarios where you would prefer a single file. My initial thinking, just like @AvdLee's was, ok maybe a single file would be faster to compile, but then after doing the testing I never got back and revisited whether it needed to be the default.

isGeneratingCustomCodingKeys

Oh wow that's a massive difference. Maybe worth checking with a different example just to confirm?

So, as far as I remember, the isGeneratingCustomCodingKeys option generates code like this (no coding keys enum is generated neither by CreateAPI, nor by the compiler):

public init(from decoder: Decoder) throws {
    let values = try decoder.container(keyedBy: StringCodingKey.self)
    self.bar = try values.decodeIfPresent(String.self, forKey: "bar")
   // ...

I'm not sure how it makes sense that this code would affect the build size in such a significant way. For one, the keys are now duplicated, but the compile most likely deduplicates the identical static strings. What's primarily missing is the coding keys enum. Are enums the root cause of the large size? This makes me think, is the default Encodable/Decodable implementation so inefficient in terms of code size?

The reasoning behind isGeneratingCustomCodingKeys being an option and not default is that one of the main goals of CreateAPI was to generate code that's readable and looks like it's written by a human.

// Default
public struct ReadOnlyFirst: Codable {
    public var bar: String?
}

// isGeneratingCustomCodingKeys
public struct ReadOnlyFirst: Codable {
    public var bar: String?

    public init(from decoder: Decoder) throws {
        let values = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar = try values.decodeIfPresent(String.self, forKey: "bar")
    }

    public func encode(to encoder: Encoder) throws {
        var values = encoder.container(keyedBy: StringCodingKey.self)
        try values.encodeIfPresent(bar, forKey: "bar")
    }
}

The default option is nicer to read. But I see how it's probably not the right trade-off given how significant the code size difference is. And for SDKs, nobody is going to be looking at that code anyway, so I'm not sure that human-readable is even the right goal. Maybe it should state "public API looks like it was written by a hand" and not "the entire code looks like it's written by hand" – that's probably a no-goal.

The name isGeneratingCustomCodingKeys is also a bit poor. It should probably just spell out the behavior: isUsingRawStringsAsCodingKeys or something like that.

liamnichols · 2022-07-28T18:10:34Z

Oh wow that's a massive difference. Maybe worth checking with a different example just to confirm?

Yeah, even I doubted it a little 😄 I build a little benchmarking playground to confirm and it seems to check out:

-	No Conformance	`Decodable` (Auto)	`Decodable` (Manual)	`StringCodingKey`
Size	556 kB	3,501 kB	3,018 kB	929 kB
Time	614 ms	2154 ms	2215 ms	886 ms

This was tested by compiling 300 single-property structs, you can see the source below.

Source for No Conformance

import Foundation

struct Foo1 {
    let bar1: String
}

struct Foo2 {
    let bar2: String
}

struct Foo3 {
    let bar3: String
}

struct Foo4 {
    let bar4: String
}

struct Foo5 {
    let bar5: String
}

struct Foo6 {
    let bar6: String
}

struct Foo7 {
    let bar7: String
}

struct Foo8 {
    let bar8: String
}

struct Foo9 {
    let bar9: String
}

struct Foo10 {
    let bar10: String
}

struct Foo11 {
    let bar11: String
}

struct Foo12 {
    let bar12: String
}

struct Foo13 {
    let bar13: String
}

struct Foo14 {
    let bar14: String
}

struct Foo15 {
    let bar15: String
}

struct Foo16 {
    let bar16: String
}

struct Foo17 {
    let bar17: String
}

struct Foo18 {
    let bar18: String
}

struct Foo19 {
    let bar19: String
}

struct Foo20 {
    let bar20: String
}

struct Foo21 {
    let bar21: String
}

struct Foo22 {
    let bar22: String
}

struct Foo23 {
    let bar23: String
}

struct Foo24 {
    let bar24: String
}

struct Foo25 {
    let bar25: String
}

struct Foo26 {
    let bar26: String
}

struct Foo27 {
    let bar27: String
}

struct Foo28 {
    let bar28: String
}

struct Foo29 {
    let bar29: String
}

struct Foo30 {
    let bar30: String
}

struct Foo31 {
    let bar31: String
}

struct Foo32 {
    let bar32: String
}

struct Foo33 {
    let bar33: String
}

struct Foo34 {
    let bar34: String
}

struct Foo35 {
    let bar35: String
}

struct Foo36 {
    let bar36: String
}

struct Foo37 {
    let bar37: String
}

struct Foo38 {
    let bar38: String
}

struct Foo39 {
    let bar39: String
}

struct Foo40 {
    let bar40: String
}

struct Foo41 {
    let bar41: String
}

struct Foo42 {
    let bar42: String
}

struct Foo43 {
    let bar43: String
}

struct Foo44 {
    let bar44: String
}

struct Foo45 {
    let bar45: String
}

struct Foo46 {
    let bar46: String
}

struct Foo47 {
    let bar47: String
}

struct Foo48 {
    let bar48: String
}

struct Foo49 {
    let bar49: String
}

struct Foo50 {
    let bar50: String
}

struct Foo51 {
    let bar51: String
}

struct Foo52 {
    let bar52: String
}

struct Foo53 {
    let bar53: String
}

struct Foo54 {
    let bar54: String
}

struct Foo55 {
    let bar55: String
}

struct Foo56 {
    let bar56: String
}

struct Foo57 {
    let bar57: String
}

struct Foo58 {
    let bar58: String
}

struct Foo59 {
    let bar59: String
}

struct Foo60 {
    let bar60: String
}

struct Foo61 {
    let bar61: String
}

struct Foo62 {
    let bar62: String
}

struct Foo63 {
    let bar63: String
}

struct Foo64 {
    let bar64: String
}

struct Foo65 {
    let bar65: String
}

struct Foo66 {
    let bar66: String
}

struct Foo67 {
    let bar67: String
}

struct Foo68 {
    let bar68: String
}

struct Foo69 {
    let bar69: String
}

struct Foo70 {
    let bar70: String
}

struct Foo71 {
    let bar71: String
}

struct Foo72 {
    let bar72: String
}

struct Foo73 {
    let bar73: String
}

struct Foo74 {
    let bar74: String
}

struct Foo75 {
    let bar75: String
}

struct Foo76 {
    let bar76: String
}

struct Foo77 {
    let bar77: String
}

struct Foo78 {
    let bar78: String
}

struct Foo79 {
    let bar79: String
}

struct Foo80 {
    let bar80: String
}

struct Foo81 {
    let bar81: String
}

struct Foo82 {
    let bar82: String
}

struct Foo83 {
    let bar83: String
}

struct Foo84 {
    let bar84: String
}

struct Foo85 {
    let bar85: String
}

struct Foo86 {
    let bar86: String
}

struct Foo87 {
    let bar87: String
}

struct Foo88 {
    let bar88: String
}

struct Foo89 {
    let bar89: String
}

struct Foo90 {
    let bar90: String
}

struct Foo91 {
    let bar91: String
}

struct Foo92 {
    let bar92: String
}

struct Foo93 {
    let bar93: String
}

struct Foo94 {
    let bar94: String
}

struct Foo95 {
    let bar95: String
}

struct Foo96 {
    let bar96: String
}

struct Foo97 {
    let bar97: String
}

struct Foo98 {
    let bar98: String
}

struct Foo99 {
    let bar99: String
}

struct Foo100 {
    let bar100: String
}

struct Foo101 {
    let bar101: String
}

struct Foo102 {
    let bar102: String
}

struct Foo103 {
    let bar103: String
}

struct Foo104 {
    let bar104: String
}

struct Foo105 {
    let bar105: String
}

struct Foo106 {
    let bar106: String
}

struct Foo107 {
    let bar107: String
}

struct Foo108 {
    let bar108: String
}

struct Foo109 {
    let bar109: String
}

struct Foo110 {
    let bar110: String
}

struct Foo111 {
    let bar111: String
}

struct Foo112 {
    let bar112: String
}

struct Foo113 {
    let bar113: String
}

struct Foo114 {
    let bar114: String
}

struct Foo115 {
    let bar115: String
}

struct Foo116 {
    let bar116: String
}

struct Foo117 {
    let bar117: String
}

struct Foo118 {
    let bar118: String
}

struct Foo119 {
    let bar119: String
}

struct Foo120 {
    let bar120: String
}

struct Foo121 {
    let bar121: String
}

struct Foo122 {
    let bar122: String
}

struct Foo123 {
    let bar123: String
}

struct Foo124 {
    let bar124: String
}

struct Foo125 {
    let bar125: String
}

struct Foo126 {
    let bar126: String
}

struct Foo127 {
    let bar127: String
}

struct Foo128 {
    let bar128: String
}

struct Foo129 {
    let bar129: String
}

struct Foo130 {
    let bar130: String
}

struct Foo131 {
    let bar131: String
}

struct Foo132 {
    let bar132: String
}

struct Foo133 {
    let bar133: String
}

struct Foo134 {
    let bar134: String
}

struct Foo135 {
    let bar135: String
}

struct Foo136 {
    let bar136: String
}

struct Foo137 {
    let bar137: String
}

struct Foo138 {
    let bar138: String
}

struct Foo139 {
    let bar139: String
}

struct Foo140 {
    let bar140: String
}

struct Foo141 {
    let bar141: String
}

struct Foo142 {
    let bar142: String
}

struct Foo143 {
    let bar143: String
}

struct Foo144 {
    let bar144: String
}

struct Foo145 {
    let bar145: String
}

struct Foo146 {
    let bar146: String
}

struct Foo147 {
    let bar147: String
}

struct Foo148 {
    let bar148: String
}

struct Foo149 {
    let bar149: String
}

struct Foo150 {
    let bar150: String
}

struct Foo151 {
    let bar151: String
}

struct Foo152 {
    let bar152: String
}

struct Foo153 {
    let bar153: String
}

struct Foo154 {
    let bar154: String
}

struct Foo155 {
    let bar155: String
}

struct Foo156 {
    let bar156: String
}

struct Foo157 {
    let bar157: String
}

struct Foo158 {
    let bar158: String
}

struct Foo159 {
    let bar159: String
}

struct Foo160 {
    let bar160: String
}

struct Foo161 {
    let bar161: String
}

struct Foo162 {
    let bar162: String
}

struct Foo163 {
    let bar163: String
}

struct Foo164 {
    let bar164: String
}

struct Foo165 {
    let bar165: String
}

struct Foo166 {
    let bar166: String
}

struct Foo167 {
    let bar167: String
}

struct Foo168 {
    let bar168: String
}

struct Foo169 {
    let bar169: String
}

struct Foo170 {
    let bar170: String
}

struct Foo171 {
    let bar171: String
}

struct Foo172 {
    let bar172: String
}

struct Foo173 {
    let bar173: String
}

struct Foo174 {
    let bar174: String
}

struct Foo175 {
    let bar175: String
}

struct Foo176 {
    let bar176: String
}

struct Foo177 {
    let bar177: String
}

struct Foo178 {
    let bar178: String
}

struct Foo179 {
    let bar179: String
}

struct Foo180 {
    let bar180: String
}

struct Foo181 {
    let bar181: String
}

struct Foo182 {
    let bar182: String
}

struct Foo183 {
    let bar183: String
}

struct Foo184 {
    let bar184: String
}

struct Foo185 {
    let bar185: String
}

struct Foo186 {
    let bar186: String
}

struct Foo187 {
    let bar187: String
}

struct Foo188 {
    let bar188: String
}

struct Foo189 {
    let bar189: String
}

struct Foo190 {
    let bar190: String
}

struct Foo191 {
    let bar191: String
}

struct Foo192 {
    let bar192: String
}

struct Foo193 {
    let bar193: String
}

struct Foo194 {
    let bar194: String
}

struct Foo195 {
    let bar195: String
}

struct Foo196 {
    let bar196: String
}

struct Foo197 {
    let bar197: String
}

struct Foo198 {
    let bar198: String
}

struct Foo199 {
    let bar199: String
}

struct Foo200 {
    let bar200: String
}

struct Foo201 {
    let bar201: String
}

struct Foo202 {
    let bar202: String
}

struct Foo203 {
    let bar203: String
}

struct Foo204 {
    let bar204: String
}

struct Foo205 {
    let bar205: String
}

struct Foo206 {
    let bar206: String
}

struct Foo207 {
    let bar207: String
}

struct Foo208 {
    let bar208: String
}

struct Foo209 {
    let bar209: String
}

struct Foo210 {
    let bar210: String
}

struct Foo211 {
    let bar211: String
}

struct Foo212 {
    let bar212: String
}

struct Foo213 {
    let bar213: String
}

struct Foo214 {
    let bar214: String
}

struct Foo215 {
    let bar215: String
}

struct Foo216 {
    let bar216: String
}

struct Foo217 {
    let bar217: String
}

struct Foo218 {
    let bar218: String
}

struct Foo219 {
    let bar219: String
}

struct Foo220 {
    let bar220: String
}

struct Foo221 {
    let bar221: String
}

struct Foo222 {
    let bar222: String
}

struct Foo223 {
    let bar223: String
}

struct Foo224 {
    let bar224: String
}

struct Foo225 {
    let bar225: String
}

struct Foo226 {
    let bar226: String
}

struct Foo227 {
    let bar227: String
}

struct Foo228 {
    let bar228: String
}

struct Foo229 {
    let bar229: String
}

struct Foo230 {
    let bar230: String
}

struct Foo231 {
    let bar231: String
}

struct Foo232 {
    let bar232: String
}

struct Foo233 {
    let bar233: String
}

struct Foo234 {
    let bar234: String
}

struct Foo235 {
    let bar235: String
}

struct Foo236 {
    let bar236: String
}

struct Foo237 {
    let bar237: String
}

struct Foo238 {
    let bar238: String
}

struct Foo239 {
    let bar239: String
}

struct Foo240 {
    let bar240: String
}

struct Foo241 {
    let bar241: String
}

struct Foo242 {
    let bar242: String
}

struct Foo243 {
    let bar243: String
}

struct Foo244 {
    let bar244: String
}

struct Foo245 {
    let bar245: String
}

struct Foo246 {
    let bar246: String
}

struct Foo247 {
    let bar247: String
}

struct Foo248 {
    let bar248: String
}

struct Foo249 {
    let bar249: String
}

struct Foo250 {
    let bar250: String
}

struct Foo251 {
    let bar251: String
}

struct Foo252 {
    let bar252: String
}

struct Foo253 {
    let bar253: String
}

struct Foo254 {
    let bar254: String
}

struct Foo255 {
    let bar255: String
}

struct Foo256 {
    let bar256: String
}

struct Foo257 {
    let bar257: String
}

struct Foo258 {
    let bar258: String
}

struct Foo259 {
    let bar259: String
}

struct Foo260 {
    let bar260: String
}

struct Foo261 {
    let bar261: String
}

struct Foo262 {
    let bar262: String
}

struct Foo263 {
    let bar263: String
}

struct Foo264 {
    let bar264: String
}

struct Foo265 {
    let bar265: String
}

struct Foo266 {
    let bar266: String
}

struct Foo267 {
    let bar267: String
}

struct Foo268 {
    let bar268: String
}

struct Foo269 {
    let bar269: String
}

struct Foo270 {
    let bar270: String
}

struct Foo271 {
    let bar271: String
}

struct Foo272 {
    let bar272: String
}

struct Foo273 {
    let bar273: String
}

struct Foo274 {
    let bar274: String
}

struct Foo275 {
    let bar275: String
}

struct Foo276 {
    let bar276: String
}

struct Foo277 {
    let bar277: String
}

struct Foo278 {
    let bar278: String
}

struct Foo279 {
    let bar279: String
}

struct Foo280 {
    let bar280: String
}

struct Foo281 {
    let bar281: String
}

struct Foo282 {
    let bar282: String
}

struct Foo283 {
    let bar283: String
}

struct Foo284 {
    let bar284: String
}

struct Foo285 {
    let bar285: String
}

struct Foo286 {
    let bar286: String
}

struct Foo287 {
    let bar287: String
}

struct Foo288 {
    let bar288: String
}

struct Foo289 {
    let bar289: String
}

struct Foo290 {
    let bar290: String
}

struct Foo291 {
    let bar291: String
}

struct Foo292 {
    let bar292: String
}

struct Foo293 {
    let bar293: String
}

struct Foo294 {
    let bar294: String
}

struct Foo295 {
    let bar295: String
}

struct Foo296 {
    let bar296: String
}

struct Foo297 {
    let bar297: String
}

struct Foo298 {
    let bar298: String
}

struct Foo299 {
    let bar299: String
}

struct Foo300 {
    let bar300: String
}

Source for `Decodable` (Auto)

import Foundation

struct Foo1: Decodable {
    let bar1: String
}

struct Foo2: Decodable {
    let bar2: String
}

struct Foo3: Decodable {
    let bar3: String
}

struct Foo4: Decodable {
    let bar4: String
}

struct Foo5: Decodable {
    let bar5: String
}

struct Foo6: Decodable {
    let bar6: String
}

struct Foo7: Decodable {
    let bar7: String
}

struct Foo8: Decodable {
    let bar8: String
}

struct Foo9: Decodable {
    let bar9: String
}

struct Foo10: Decodable {
    let bar10: String
}

struct Foo11: Decodable {
    let bar11: String
}

struct Foo12: Decodable {
    let bar12: String
}

struct Foo13: Decodable {
    let bar13: String
}

struct Foo14: Decodable {
    let bar14: String
}

struct Foo15: Decodable {
    let bar15: String
}

struct Foo16: Decodable {
    let bar16: String
}

struct Foo17: Decodable {
    let bar17: String
}

struct Foo18: Decodable {
    let bar18: String
}

struct Foo19: Decodable {
    let bar19: String
}

struct Foo20: Decodable {
    let bar20: String
}

struct Foo21: Decodable {
    let bar21: String
}

struct Foo22: Decodable {
    let bar22: String
}

struct Foo23: Decodable {
    let bar23: String
}

struct Foo24: Decodable {
    let bar24: String
}

struct Foo25: Decodable {
    let bar25: String
}

struct Foo26: Decodable {
    let bar26: String
}

struct Foo27: Decodable {
    let bar27: String
}

struct Foo28: Decodable {
    let bar28: String
}

struct Foo29: Decodable {
    let bar29: String
}

struct Foo30: Decodable {
    let bar30: String
}

struct Foo31: Decodable {
    let bar31: String
}

struct Foo32: Decodable {
    let bar32: String
}

struct Foo33: Decodable {
    let bar33: String
}

struct Foo34: Decodable {
    let bar34: String
}

struct Foo35: Decodable {
    let bar35: String
}

struct Foo36: Decodable {
    let bar36: String
}

struct Foo37: Decodable {
    let bar37: String
}

struct Foo38: Decodable {
    let bar38: String
}

struct Foo39: Decodable {
    let bar39: String
}

struct Foo40: Decodable {
    let bar40: String
}

struct Foo41: Decodable {
    let bar41: String
}

struct Foo42: Decodable {
    let bar42: String
}

struct Foo43: Decodable {
    let bar43: String
}

struct Foo44: Decodable {
    let bar44: String
}

struct Foo45: Decodable {
    let bar45: String
}

struct Foo46: Decodable {
    let bar46: String
}

struct Foo47: Decodable {
    let bar47: String
}

struct Foo48: Decodable {
    let bar48: String
}

struct Foo49: Decodable {
    let bar49: String
}

struct Foo50: Decodable {
    let bar50: String
}

struct Foo51: Decodable {
    let bar51: String
}

struct Foo52: Decodable {
    let bar52: String
}

struct Foo53: Decodable {
    let bar53: String
}

struct Foo54: Decodable {
    let bar54: String
}

struct Foo55: Decodable {
    let bar55: String
}

struct Foo56: Decodable {
    let bar56: String
}

struct Foo57: Decodable {
    let bar57: String
}

struct Foo58: Decodable {
    let bar58: String
}

struct Foo59: Decodable {
    let bar59: String
}

struct Foo60: Decodable {
    let bar60: String
}

struct Foo61: Decodable {
    let bar61: String
}

struct Foo62: Decodable {
    let bar62: String
}

struct Foo63: Decodable {
    let bar63: String
}

struct Foo64: Decodable {
    let bar64: String
}

struct Foo65: Decodable {
    let bar65: String
}

struct Foo66: Decodable {
    let bar66: String
}

struct Foo67: Decodable {
    let bar67: String
}

struct Foo68: Decodable {
    let bar68: String
}

struct Foo69: Decodable {
    let bar69: String
}

struct Foo70: Decodable {
    let bar70: String
}

struct Foo71: Decodable {
    let bar71: String
}

struct Foo72: Decodable {
    let bar72: String
}

struct Foo73: Decodable {
    let bar73: String
}

struct Foo74: Decodable {
    let bar74: String
}

struct Foo75: Decodable {
    let bar75: String
}

struct Foo76: Decodable {
    let bar76: String
}

struct Foo77: Decodable {
    let bar77: String
}

struct Foo78: Decodable {
    let bar78: String
}

struct Foo79: Decodable {
    let bar79: String
}

struct Foo80: Decodable {
    let bar80: String
}

struct Foo81: Decodable {
    let bar81: String
}

struct Foo82: Decodable {
    let bar82: String
}

struct Foo83: Decodable {
    let bar83: String
}

struct Foo84: Decodable {
    let bar84: String
}

struct Foo85: Decodable {
    let bar85: String
}

struct Foo86: Decodable {
    let bar86: String
}

struct Foo87: Decodable {
    let bar87: String
}

struct Foo88: Decodable {
    let bar88: String
}

struct Foo89: Decodable {
    let bar89: String
}

struct Foo90: Decodable {
    let bar90: String
}

struct Foo91: Decodable {
    let bar91: String
}

struct Foo92: Decodable {
    let bar92: String
}

struct Foo93: Decodable {
    let bar93: String
}

struct Foo94: Decodable {
    let bar94: String
}

struct Foo95: Decodable {
    let bar95: String
}

struct Foo96: Decodable {
    let bar96: String
}

struct Foo97: Decodable {
    let bar97: String
}

struct Foo98: Decodable {
    let bar98: String
}

struct Foo99: Decodable {
    let bar99: String
}

struct Foo100: Decodable {
    let bar100: String
}

struct Foo101: Decodable {
    let bar101: String
}

struct Foo102: Decodable {
    let bar102: String
}

struct Foo103: Decodable {
    let bar103: String
}

struct Foo104: Decodable {
    let bar104: String
}

struct Foo105: Decodable {
    let bar105: String
}

struct Foo106: Decodable {
    let bar106: String
}

struct Foo107: Decodable {
    let bar107: String
}

struct Foo108: Decodable {
    let bar108: String
}

struct Foo109: Decodable {
    let bar109: String
}

struct Foo110: Decodable {
    let bar110: String
}

struct Foo111: Decodable {
    let bar111: String
}

struct Foo112: Decodable {
    let bar112: String
}

struct Foo113: Decodable {
    let bar113: String
}

struct Foo114: Decodable {
    let bar114: String
}

struct Foo115: Decodable {
    let bar115: String
}

struct Foo116: Decodable {
    let bar116: String
}

struct Foo117: Decodable {
    let bar117: String
}

struct Foo118: Decodable {
    let bar118: String
}

struct Foo119: Decodable {
    let bar119: String
}

struct Foo120: Decodable {
    let bar120: String
}

struct Foo121: Decodable {
    let bar121: String
}

struct Foo122: Decodable {
    let bar122: String
}

struct Foo123: Decodable {
    let bar123: String
}

struct Foo124: Decodable {
    let bar124: String
}

struct Foo125: Decodable {
    let bar125: String
}

struct Foo126: Decodable {
    let bar126: String
}

struct Foo127: Decodable {
    let bar127: String
}

struct Foo128: Decodable {
    let bar128: String
}

struct Foo129: Decodable {
    let bar129: String
}

struct Foo130: Decodable {
    let bar130: String
}

struct Foo131: Decodable {
    let bar131: String
}

struct Foo132: Decodable {
    let bar132: String
}

struct Foo133: Decodable {
    let bar133: String
}

struct Foo134: Decodable {
    let bar134: String
}

struct Foo135: Decodable {
    let bar135: String
}

struct Foo136: Decodable {
    let bar136: String
}

struct Foo137: Decodable {
    let bar137: String
}

struct Foo138: Decodable {
    let bar138: String
}

struct Foo139: Decodable {
    let bar139: String
}

struct Foo140: Decodable {
    let bar140: String
}

struct Foo141: Decodable {
    let bar141: String
}

struct Foo142: Decodable {
    let bar142: String
}

struct Foo143: Decodable {
    let bar143: String
}

struct Foo144: Decodable {
    let bar144: String
}

struct Foo145: Decodable {
    let bar145: String
}

struct Foo146: Decodable {
    let bar146: String
}

struct Foo147: Decodable {
    let bar147: String
}

struct Foo148: Decodable {
    let bar148: String
}

struct Foo149: Decodable {
    let bar149: String
}

struct Foo150: Decodable {
    let bar150: String
}

struct Foo151: Decodable {
    let bar151: String
}

struct Foo152: Decodable {
    let bar152: String
}

struct Foo153: Decodable {
    let bar153: String
}

struct Foo154: Decodable {
    let bar154: String
}

struct Foo155: Decodable {
    let bar155: String
}

struct Foo156: Decodable {
    let bar156: String
}

struct Foo157: Decodable {
    let bar157: String
}

struct Foo158: Decodable {
    let bar158: String
}

struct Foo159: Decodable {
    let bar159: String
}

struct Foo160: Decodable {
    let bar160: String
}

struct Foo161: Decodable {
    let bar161: String
}

struct Foo162: Decodable {
    let bar162: String
}

struct Foo163: Decodable {
    let bar163: String
}

struct Foo164: Decodable {
    let bar164: String
}

struct Foo165: Decodable {
    let bar165: String
}

struct Foo166: Decodable {
    let bar166: String
}

struct Foo167: Decodable {
    let bar167: String
}

struct Foo168: Decodable {
    let bar168: String
}

struct Foo169: Decodable {
    let bar169: String
}

struct Foo170: Decodable {
    let bar170: String
}

struct Foo171: Decodable {
    let bar171: String
}

struct Foo172: Decodable {
    let bar172: String
}

struct Foo173: Decodable {
    let bar173: String
}

struct Foo174: Decodable {
    let bar174: String
}

struct Foo175: Decodable {
    let bar175: String
}

struct Foo176: Decodable {
    let bar176: String
}

struct Foo177: Decodable {
    let bar177: String
}

struct Foo178: Decodable {
    let bar178: String
}

struct Foo179: Decodable {
    let bar179: String
}

struct Foo180: Decodable {
    let bar180: String
}

struct Foo181: Decodable {
    let bar181: String
}

struct Foo182: Decodable {
    let bar182: String
}

struct Foo183: Decodable {
    let bar183: String
}

struct Foo184: Decodable {
    let bar184: String
}

struct Foo185: Decodable {
    let bar185: String
}

struct Foo186: Decodable {
    let bar186: String
}

struct Foo187: Decodable {
    let bar187: String
}

struct Foo188: Decodable {
    let bar188: String
}

struct Foo189: Decodable {
    let bar189: String
}

struct Foo190: Decodable {
    let bar190: String
}

struct Foo191: Decodable {
    let bar191: String
}

struct Foo192: Decodable {
    let bar192: String
}

struct Foo193: Decodable {
    let bar193: String
}

struct Foo194: Decodable {
    let bar194: String
}

struct Foo195: Decodable {
    let bar195: String
}

struct Foo196: Decodable {
    let bar196: String
}

struct Foo197: Decodable {
    let bar197: String
}

struct Foo198: Decodable {
    let bar198: String
}

struct Foo199: Decodable {
    let bar199: String
}

struct Foo200: Decodable {
    let bar200: String
}

struct Foo201: Decodable {
    let bar201: String
}

struct Foo202: Decodable {
    let bar202: String
}

struct Foo203: Decodable {
    let bar203: String
}

struct Foo204: Decodable {
    let bar204: String
}

struct Foo205: Decodable {
    let bar205: String
}

struct Foo206: Decodable {
    let bar206: String
}

struct Foo207: Decodable {
    let bar207: String
}

struct Foo208: Decodable {
    let bar208: String
}

struct Foo209: Decodable {
    let bar209: String
}

struct Foo210: Decodable {
    let bar210: String
}

struct Foo211: Decodable {
    let bar211: String
}

struct Foo212: Decodable {
    let bar212: String
}

struct Foo213: Decodable {
    let bar213: String
}

struct Foo214: Decodable {
    let bar214: String
}

struct Foo215: Decodable {
    let bar215: String
}

struct Foo216: Decodable {
    let bar216: String
}

struct Foo217: Decodable {
    let bar217: String
}

struct Foo218: Decodable {
    let bar218: String
}

struct Foo219: Decodable {
    let bar219: String
}

struct Foo220: Decodable {
    let bar220: String
}

struct Foo221: Decodable {
    let bar221: String
}

struct Foo222: Decodable {
    let bar222: String
}

struct Foo223: Decodable {
    let bar223: String
}

struct Foo224: Decodable {
    let bar224: String
}

struct Foo225: Decodable {
    let bar225: String
}

struct Foo226: Decodable {
    let bar226: String
}

struct Foo227: Decodable {
    let bar227: String
}

struct Foo228: Decodable {
    let bar228: String
}

struct Foo229: Decodable {
    let bar229: String
}

struct Foo230: Decodable {
    let bar230: String
}

struct Foo231: Decodable {
    let bar231: String
}

struct Foo232: Decodable {
    let bar232: String
}

struct Foo233: Decodable {
    let bar233: String
}

struct Foo234: Decodable {
    let bar234: String
}

struct Foo235: Decodable {
    let bar235: String
}

struct Foo236: Decodable {
    let bar236: String
}

struct Foo237: Decodable {
    let bar237: String
}

struct Foo238: Decodable {
    let bar238: String
}

struct Foo239: Decodable {
    let bar239: String
}

struct Foo240: Decodable {
    let bar240: String
}

struct Foo241: Decodable {
    let bar241: String
}

struct Foo242: Decodable {
    let bar242: String
}

struct Foo243: Decodable {
    let bar243: String
}

struct Foo244: Decodable {
    let bar244: String
}

struct Foo245: Decodable {
    let bar245: String
}

struct Foo246: Decodable {
    let bar246: String
}

struct Foo247: Decodable {
    let bar247: String
}

struct Foo248: Decodable {
    let bar248: String
}

struct Foo249: Decodable {
    let bar249: String
}

struct Foo250: Decodable {
    let bar250: String
}

struct Foo251: Decodable {
    let bar251: String
}

struct Foo252: Decodable {
    let bar252: String
}

struct Foo253: Decodable {
    let bar253: String
}

struct Foo254: Decodable {
    let bar254: String
}

struct Foo255: Decodable {
    let bar255: String
}

struct Foo256: Decodable {
    let bar256: String
}

struct Foo257: Decodable {
    let bar257: String
}

struct Foo258: Decodable {
    let bar258: String
}

struct Foo259: Decodable {
    let bar259: String
}

struct Foo260: Decodable {
    let bar260: String
}

struct Foo261: Decodable {
    let bar261: String
}

struct Foo262: Decodable {
    let bar262: String
}

struct Foo263: Decodable {
    let bar263: String
}

struct Foo264: Decodable {
    let bar264: String
}

struct Foo265: Decodable {
    let bar265: String
}

struct Foo266: Decodable {
    let bar266: String
}

struct Foo267: Decodable {
    let bar267: String
}

struct Foo268: Decodable {
    let bar268: String
}

struct Foo269: Decodable {
    let bar269: String
}

struct Foo270: Decodable {
    let bar270: String
}

struct Foo271: Decodable {
    let bar271: String
}

struct Foo272: Decodable {
    let bar272: String
}

struct Foo273: Decodable {
    let bar273: String
}

struct Foo274: Decodable {
    let bar274: String
}

struct Foo275: Decodable {
    let bar275: String
}

struct Foo276: Decodable {
    let bar276: String
}

struct Foo277: Decodable {
    let bar277: String
}

struct Foo278: Decodable {
    let bar278: String
}

struct Foo279: Decodable {
    let bar279: String
}

struct Foo280: Decodable {
    let bar280: String
}

struct Foo281: Decodable {
    let bar281: String
}

struct Foo282: Decodable {
    let bar282: String
}

struct Foo283: Decodable {
    let bar283: String
}

struct Foo284: Decodable {
    let bar284: String
}

struct Foo285: Decodable {
    let bar285: String
}

struct Foo286: Decodable {
    let bar286: String
}

struct Foo287: Decodable {
    let bar287: String
}

struct Foo288: Decodable {
    let bar288: String
}

struct Foo289: Decodable {
    let bar289: String
}

struct Foo290: Decodable {
    let bar290: String
}

struct Foo291: Decodable {
    let bar291: String
}

struct Foo292: Decodable {
    let bar292: String
}

struct Foo293: Decodable {
    let bar293: String
}

struct Foo294: Decodable {
    let bar294: String
}

struct Foo295: Decodable {
    let bar295: String
}

struct Foo296: Decodable {
    let bar296: String
}

struct Foo297: Decodable {
    let bar297: String
}

struct Foo298: Decodable {
    let bar298: String
}

struct Foo299: Decodable {
    let bar299: String
}

struct Foo300: Decodable {
    let bar300: String
}

Source for `Decodable` (Manual)

import Foundation

struct Foo1: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar1
    }

    let bar1: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar1 = try container.decode(String.self, forKey: .bar1)
    }
}

struct Foo2: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar2
    }

    let bar2: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar2 = try container.decode(String.self, forKey: .bar2)
    }
}

struct Foo3: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar3
    }

    let bar3: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar3 = try container.decode(String.self, forKey: .bar3)
    }
}

struct Foo4: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar4
    }

    let bar4: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar4 = try container.decode(String.self, forKey: .bar4)
    }
}

struct Foo5: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar5
    }

    let bar5: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar5 = try container.decode(String.self, forKey: .bar5)
    }
}

struct Foo6: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar6
    }

    let bar6: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar6 = try container.decode(String.self, forKey: .bar6)
    }
}

struct Foo7: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar7
    }

    let bar7: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar7 = try container.decode(String.self, forKey: .bar7)
    }
}

struct Foo8: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar8
    }

    let bar8: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar8 = try container.decode(String.self, forKey: .bar8)
    }
}

struct Foo9: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar9
    }

    let bar9: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar9 = try container.decode(String.self, forKey: .bar9)
    }
}

struct Foo10: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar10
    }

    let bar10: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar10 = try container.decode(String.self, forKey: .bar10)
    }
}

struct Foo11: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar11
    }

    let bar11: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar11 = try container.decode(String.self, forKey: .bar11)
    }
}

struct Foo12: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar12
    }

    let bar12: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar12 = try container.decode(String.self, forKey: .bar12)
    }
}

struct Foo13: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar13
    }

    let bar13: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar13 = try container.decode(String.self, forKey: .bar13)
    }
}

struct Foo14: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar14
    }

    let bar14: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar14 = try container.decode(String.self, forKey: .bar14)
    }
}

struct Foo15: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar15
    }

    let bar15: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar15 = try container.decode(String.self, forKey: .bar15)
    }
}

struct Foo16: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar16
    }

    let bar16: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar16 = try container.decode(String.self, forKey: .bar16)
    }
}

struct Foo17: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar17
    }

    let bar17: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar17 = try container.decode(String.self, forKey: .bar17)
    }
}

struct Foo18: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar18
    }

    let bar18: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar18 = try container.decode(String.self, forKey: .bar18)
    }
}

struct Foo19: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar19
    }

    let bar19: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar19 = try container.decode(String.self, forKey: .bar19)
    }
}

struct Foo20: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar20
    }

    let bar20: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar20 = try container.decode(String.self, forKey: .bar20)
    }
}

struct Foo21: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar21
    }

    let bar21: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar21 = try container.decode(String.self, forKey: .bar21)
    }
}

struct Foo22: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar22
    }

    let bar22: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar22 = try container.decode(String.self, forKey: .bar22)
    }
}

struct Foo23: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar23
    }

    let bar23: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar23 = try container.decode(String.self, forKey: .bar23)
    }
}

struct Foo24: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar24
    }

    let bar24: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar24 = try container.decode(String.self, forKey: .bar24)
    }
}

struct Foo25: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar25
    }

    let bar25: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar25 = try container.decode(String.self, forKey: .bar25)
    }
}

struct Foo26: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar26
    }

    let bar26: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar26 = try container.decode(String.self, forKey: .bar26)
    }
}

struct Foo27: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar27
    }

    let bar27: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar27 = try container.decode(String.self, forKey: .bar27)
    }
}

struct Foo28: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar28
    }

    let bar28: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar28 = try container.decode(String.self, forKey: .bar28)
    }
}

struct Foo29: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar29
    }

    let bar29: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar29 = try container.decode(String.self, forKey: .bar29)
    }
}

struct Foo30: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar30
    }

    let bar30: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar30 = try container.decode(String.self, forKey: .bar30)
    }
}

struct Foo31: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar31
    }

    let bar31: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar31 = try container.decode(String.self, forKey: .bar31)
    }
}

struct Foo32: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar32
    }

    let bar32: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar32 = try container.decode(String.self, forKey: .bar32)
    }
}

struct Foo33: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar33
    }

    let bar33: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar33 = try container.decode(String.self, forKey: .bar33)
    }
}

struct Foo34: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar34
    }

    let bar34: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar34 = try container.decode(String.self, forKey: .bar34)
    }
}

struct Foo35: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar35
    }

    let bar35: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar35 = try container.decode(String.self, forKey: .bar35)
    }
}

struct Foo36: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar36
    }

    let bar36: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar36 = try container.decode(String.self, forKey: .bar36)
    }
}

struct Foo37: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar37
    }

    let bar37: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar37 = try container.decode(String.self, forKey: .bar37)
    }
}

struct Foo38: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar38
    }

    let bar38: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar38 = try container.decode(String.self, forKey: .bar38)
    }
}

struct Foo39: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar39
    }

    let bar39: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar39 = try container.decode(String.self, forKey: .bar39)
    }
}

struct Foo40: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar40
    }

    let bar40: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar40 = try container.decode(String.self, forKey: .bar40)
    }
}

struct Foo41: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar41
    }

    let bar41: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar41 = try container.decode(String.self, forKey: .bar41)
    }
}

struct Foo42: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar42
    }

    let bar42: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar42 = try container.decode(String.self, forKey: .bar42)
    }
}

struct Foo43: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar43
    }

    let bar43: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar43 = try container.decode(String.self, forKey: .bar43)
    }
}

struct Foo44: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar44
    }

    let bar44: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar44 = try container.decode(String.self, forKey: .bar44)
    }
}

struct Foo45: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar45
    }

    let bar45: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar45 = try container.decode(String.self, forKey: .bar45)
    }
}

struct Foo46: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar46
    }

    let bar46: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar46 = try container.decode(String.self, forKey: .bar46)
    }
}

struct Foo47: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar47
    }

    let bar47: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar47 = try container.decode(String.self, forKey: .bar47)
    }
}

struct Foo48: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar48
    }

    let bar48: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar48 = try container.decode(String.self, forKey: .bar48)
    }
}

struct Foo49: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar49
    }

    let bar49: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar49 = try container.decode(String.self, forKey: .bar49)
    }
}

struct Foo50: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar50
    }

    let bar50: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar50 = try container.decode(String.self, forKey: .bar50)
    }
}

struct Foo51: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar51
    }

    let bar51: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar51 = try container.decode(String.self, forKey: .bar51)
    }
}

struct Foo52: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar52
    }

    let bar52: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar52 = try container.decode(String.self, forKey: .bar52)
    }
}

struct Foo53: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar53
    }

    let bar53: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar53 = try container.decode(String.self, forKey: .bar53)
    }
}

struct Foo54: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar54
    }

    let bar54: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar54 = try container.decode(String.self, forKey: .bar54)
    }
}

struct Foo55: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar55
    }

    let bar55: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar55 = try container.decode(String.self, forKey: .bar55)
    }
}

struct Foo56: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar56
    }

    let bar56: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar56 = try container.decode(String.self, forKey: .bar56)
    }
}

struct Foo57: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar57
    }

    let bar57: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar57 = try container.decode(String.self, forKey: .bar57)
    }
}

struct Foo58: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar58
    }

    let bar58: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar58 = try container.decode(String.self, forKey: .bar58)
    }
}

struct Foo59: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar59
    }

    let bar59: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar59 = try container.decode(String.self, forKey: .bar59)
    }
}

struct Foo60: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar60
    }

    let bar60: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar60 = try container.decode(String.self, forKey: .bar60)
    }
}

struct Foo61: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar61
    }

    let bar61: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar61 = try container.decode(String.self, forKey: .bar61)
    }
}

struct Foo62: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar62
    }

    let bar62: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar62 = try container.decode(String.self, forKey: .bar62)
    }
}

struct Foo63: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar63
    }

    let bar63: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar63 = try container.decode(String.self, forKey: .bar63)
    }
}

struct Foo64: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar64
    }

    let bar64: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar64 = try container.decode(String.self, forKey: .bar64)
    }
}

struct Foo65: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar65
    }

    let bar65: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar65 = try container.decode(String.self, forKey: .bar65)
    }
}

struct Foo66: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar66
    }

    let bar66: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar66 = try container.decode(String.self, forKey: .bar66)
    }
}

struct Foo67: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar67
    }

    let bar67: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar67 = try container.decode(String.self, forKey: .bar67)
    }
}

struct Foo68: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar68
    }

    let bar68: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar68 = try container.decode(String.self, forKey: .bar68)
    }
}

struct Foo69: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar69
    }

    let bar69: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar69 = try container.decode(String.self, forKey: .bar69)
    }
}

struct Foo70: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar70
    }

    let bar70: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar70 = try container.decode(String.self, forKey: .bar70)
    }
}

struct Foo71: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar71
    }

    let bar71: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar71 = try container.decode(String.self, forKey: .bar71)
    }
}

struct Foo72: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar72
    }

    let bar72: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar72 = try container.decode(String.self, forKey: .bar72)
    }
}

struct Foo73: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar73
    }

    let bar73: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar73 = try container.decode(String.self, forKey: .bar73)
    }
}

struct Foo74: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar74
    }

    let bar74: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar74 = try container.decode(String.self, forKey: .bar74)
    }
}

struct Foo75: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar75
    }

    let bar75: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar75 = try container.decode(String.self, forKey: .bar75)
    }
}

struct Foo76: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar76
    }

    let bar76: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar76 = try container.decode(String.self, forKey: .bar76)
    }
}

struct Foo77: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar77
    }

    let bar77: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar77 = try container.decode(String.self, forKey: .bar77)
    }
}

struct Foo78: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar78
    }

    let bar78: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar78 = try container.decode(String.self, forKey: .bar78)
    }
}

struct Foo79: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar79
    }

    let bar79: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar79 = try container.decode(String.self, forKey: .bar79)
    }
}

struct Foo80: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar80
    }

    let bar80: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar80 = try container.decode(String.self, forKey: .bar80)
    }
}

struct Foo81: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar81
    }

    let bar81: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar81 = try container.decode(String.self, forKey: .bar81)
    }
}

struct Foo82: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar82
    }

    let bar82: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar82 = try container.decode(String.self, forKey: .bar82)
    }
}

struct Foo83: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar83
    }

    let bar83: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar83 = try container.decode(String.self, forKey: .bar83)
    }
}

struct Foo84: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar84
    }

    let bar84: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar84 = try container.decode(String.self, forKey: .bar84)
    }
}

struct Foo85: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar85
    }

    let bar85: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar85 = try container.decode(String.self, forKey: .bar85)
    }
}

struct Foo86: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar86
    }

    let bar86: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar86 = try container.decode(String.self, forKey: .bar86)
    }
}

struct Foo87: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar87
    }

    let bar87: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar87 = try container.decode(String.self, forKey: .bar87)
    }
}

struct Foo88: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar88
    }

    let bar88: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar88 = try container.decode(String.self, forKey: .bar88)
    }
}

struct Foo89: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar89
    }

    let bar89: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar89 = try container.decode(String.self, forKey: .bar89)
    }
}

struct Foo90: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar90
    }

    let bar90: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar90 = try container.decode(String.self, forKey: .bar90)
    }
}

struct Foo91: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar91
    }

    let bar91: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar91 = try container.decode(String.self, forKey: .bar91)
    }
}

struct Foo92: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar92
    }

    let bar92: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar92 = try container.decode(String.self, forKey: .bar92)
    }
}

struct Foo93: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar93
    }

    let bar93: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar93 = try container.decode(String.self, forKey: .bar93)
    }
}

struct Foo94: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar94
    }

    let bar94: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar94 = try container.decode(String.self, forKey: .bar94)
    }
}

struct Foo95: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar95
    }

    let bar95: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar95 = try container.decode(String.self, forKey: .bar95)
    }
}

struct Foo96: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar96
    }

    let bar96: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar96 = try container.decode(String.self, forKey: .bar96)
    }
}

struct Foo97: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar97
    }

    let bar97: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar97 = try container.decode(String.self, forKey: .bar97)
    }
}

struct Foo98: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar98
    }

    let bar98: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar98 = try container.decode(String.self, forKey: .bar98)
    }
}

struct Foo99: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar99
    }

    let bar99: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar99 = try container.decode(String.self, forKey: .bar99)
    }
}

struct Foo100: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar100
    }

    let bar100: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar100 = try container.decode(String.self, forKey: .bar100)
    }
}

struct Foo101: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar101
    }

    let bar101: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar101 = try container.decode(String.self, forKey: .bar101)
    }
}

struct Foo102: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar102
    }

    let bar102: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar102 = try container.decode(String.self, forKey: .bar102)
    }
}

struct Foo103: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar103
    }

    let bar103: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar103 = try container.decode(String.self, forKey: .bar103)
    }
}

struct Foo104: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar104
    }

    let bar104: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar104 = try container.decode(String.self, forKey: .bar104)
    }
}

struct Foo105: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar105
    }

    let bar105: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar105 = try container.decode(String.self, forKey: .bar105)
    }
}

struct Foo106: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar106
    }

    let bar106: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar106 = try container.decode(String.self, forKey: .bar106)
    }
}

struct Foo107: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar107
    }

    let bar107: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar107 = try container.decode(String.self, forKey: .bar107)
    }
}

struct Foo108: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar108
    }

    let bar108: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar108 = try container.decode(String.self, forKey: .bar108)
    }
}

struct Foo109: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar109
    }

    let bar109: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar109 = try container.decode(String.self, forKey: .bar109)
    }
}

struct Foo110: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar110
    }

    let bar110: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar110 = try container.decode(String.self, forKey: .bar110)
    }
}

struct Foo111: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar111
    }

    let bar111: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar111 = try container.decode(String.self, forKey: .bar111)
    }
}

struct Foo112: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar112
    }

    let bar112: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar112 = try container.decode(String.self, forKey: .bar112)
    }
}

struct Foo113: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar113
    }

    let bar113: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar113 = try container.decode(String.self, forKey: .bar113)
    }
}

struct Foo114: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar114
    }

    let bar114: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar114 = try container.decode(String.self, forKey: .bar114)
    }
}

struct Foo115: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar115
    }

    let bar115: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar115 = try container.decode(String.self, forKey: .bar115)
    }
}

struct Foo116: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar116
    }

    let bar116: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar116 = try container.decode(String.self, forKey: .bar116)
    }
}

struct Foo117: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar117
    }

    let bar117: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar117 = try container.decode(String.self, forKey: .bar117)
    }
}

struct Foo118: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar118
    }

    let bar118: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar118 = try container.decode(String.self, forKey: .bar118)
    }
}

struct Foo119: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar119
    }

    let bar119: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar119 = try container.decode(String.self, forKey: .bar119)
    }
}

struct Foo120: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar120
    }

    let bar120: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar120 = try container.decode(String.self, forKey: .bar120)
    }
}

struct Foo121: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar121
    }

    let bar121: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar121 = try container.decode(String.self, forKey: .bar121)
    }
}

struct Foo122: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar122
    }

    let bar122: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar122 = try container.decode(String.self, forKey: .bar122)
    }
}

struct Foo123: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar123
    }

    let bar123: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar123 = try container.decode(String.self, forKey: .bar123)
    }
}

struct Foo124: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar124
    }

    let bar124: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar124 = try container.decode(String.self, forKey: .bar124)
    }
}

struct Foo125: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar125
    }

    let bar125: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar125 = try container.decode(String.self, forKey: .bar125)
    }
}

struct Foo126: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar126
    }

    let bar126: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar126 = try container.decode(String.self, forKey: .bar126)
    }
}

struct Foo127: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar127
    }

    let bar127: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar127 = try container.decode(String.self, forKey: .bar127)
    }
}

struct Foo128: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar128
    }

    let bar128: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar128 = try container.decode(String.self, forKey: .bar128)
    }
}

struct Foo129: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar129
    }

    let bar129: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar129 = try container.decode(String.self, forKey: .bar129)
    }
}

struct Foo130: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar130
    }

    let bar130: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar130 = try container.decode(String.self, forKey: .bar130)
    }
}

struct Foo131: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar131
    }

    let bar131: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar131 = try container.decode(String.self, forKey: .bar131)
    }
}

struct Foo132: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar132
    }

    let bar132: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar132 = try container.decode(String.self, forKey: .bar132)
    }
}

struct Foo133: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar133
    }

    let bar133: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar133 = try container.decode(String.self, forKey: .bar133)
    }
}

struct Foo134: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar134
    }

    let bar134: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar134 = try container.decode(String.self, forKey: .bar134)
    }
}

struct Foo135: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar135
    }

    let bar135: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar135 = try container.decode(String.self, forKey: .bar135)
    }
}

struct Foo136: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar136
    }

    let bar136: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar136 = try container.decode(String.self, forKey: .bar136)
    }
}

struct Foo137: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar137
    }

    let bar137: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar137 = try container.decode(String.self, forKey: .bar137)
    }
}

struct Foo138: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar138
    }

    let bar138: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar138 = try container.decode(String.self, forKey: .bar138)
    }
}

struct Foo139: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar139
    }

    let bar139: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar139 = try container.decode(String.self, forKey: .bar139)
    }
}

struct Foo140: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar140
    }

    let bar140: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar140 = try container.decode(String.self, forKey: .bar140)
    }
}

struct Foo141: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar141
    }

    let bar141: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar141 = try container.decode(String.self, forKey: .bar141)
    }
}

struct Foo142: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar142
    }

    let bar142: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar142 = try container.decode(String.self, forKey: .bar142)
    }
}

struct Foo143: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar143
    }

    let bar143: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar143 = try container.decode(String.self, forKey: .bar143)
    }
}

struct Foo144: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar144
    }

    let bar144: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar144 = try container.decode(String.self, forKey: .bar144)
    }
}

struct Foo145: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar145
    }

    let bar145: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar145 = try container.decode(String.self, forKey: .bar145)
    }
}

struct Foo146: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar146
    }

    let bar146: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar146 = try container.decode(String.self, forKey: .bar146)
    }
}

struct Foo147: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar147
    }

    let bar147: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar147 = try container.decode(String.self, forKey: .bar147)
    }
}

struct Foo148: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar148
    }

    let bar148: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar148 = try container.decode(String.self, forKey: .bar148)
    }
}

struct Foo149: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar149
    }

    let bar149: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar149 = try container.decode(String.self, forKey: .bar149)
    }
}

struct Foo150: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar150
    }

    let bar150: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar150 = try container.decode(String.self, forKey: .bar150)
    }
}

struct Foo151: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar151
    }

    let bar151: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar151 = try container.decode(String.self, forKey: .bar151)
    }
}

struct Foo152: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar152
    }

    let bar152: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar152 = try container.decode(String.self, forKey: .bar152)
    }
}

struct Foo153: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar153
    }

    let bar153: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar153 = try container.decode(String.self, forKey: .bar153)
    }
}

struct Foo154: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar154
    }

    let bar154: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar154 = try container.decode(String.self, forKey: .bar154)
    }
}

struct Foo155: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar155
    }

    let bar155: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar155 = try container.decode(String.self, forKey: .bar155)
    }
}

struct Foo156: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar156
    }

    let bar156: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar156 = try container.decode(String.self, forKey: .bar156)
    }
}

struct Foo157: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar157
    }

    let bar157: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar157 = try container.decode(String.self, forKey: .bar157)
    }
}

struct Foo158: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar158
    }

    let bar158: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar158 = try container.decode(String.self, forKey: .bar158)
    }
}

struct Foo159: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar159
    }

    let bar159: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar159 = try container.decode(String.self, forKey: .bar159)
    }
}

struct Foo160: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar160
    }

    let bar160: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar160 = try container.decode(String.self, forKey: .bar160)
    }
}

struct Foo161: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar161
    }

    let bar161: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar161 = try container.decode(String.self, forKey: .bar161)
    }
}

struct Foo162: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar162
    }

    let bar162: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar162 = try container.decode(String.self, forKey: .bar162)
    }
}

struct Foo163: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar163
    }

    let bar163: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar163 = try container.decode(String.self, forKey: .bar163)
    }
}

struct Foo164: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar164
    }

    let bar164: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar164 = try container.decode(String.self, forKey: .bar164)
    }
}

struct Foo165: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar165
    }

    let bar165: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar165 = try container.decode(String.self, forKey: .bar165)
    }
}

struct Foo166: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar166
    }

    let bar166: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar166 = try container.decode(String.self, forKey: .bar166)
    }
}

struct Foo167: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar167
    }

    let bar167: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar167 = try container.decode(String.self, forKey: .bar167)
    }
}

struct Foo168: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar168
    }

    let bar168: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar168 = try container.decode(String.self, forKey: .bar168)
    }
}

struct Foo169: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar169
    }

    let bar169: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar169 = try container.decode(String.self, forKey: .bar169)
    }
}

struct Foo170: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar170
    }

    let bar170: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar170 = try container.decode(String.self, forKey: .bar170)
    }
}

struct Foo171: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar171
    }

    let bar171: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar171 = try container.decode(String.self, forKey: .bar171)
    }
}

struct Foo172: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar172
    }

    let bar172: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar172 = try container.decode(String.self, forKey: .bar172)
    }
}

struct Foo173: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar173
    }

    let bar173: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar173 = try container.decode(String.self, forKey: .bar173)
    }
}

struct Foo174: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar174
    }

    let bar174: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar174 = try container.decode(String.self, forKey: .bar174)
    }
}

struct Foo175: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar175
    }

    let bar175: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar175 = try container.decode(String.self, forKey: .bar175)
    }
}

struct Foo176: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar176
    }

    let bar176: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar176 = try container.decode(String.self, forKey: .bar176)
    }
}

struct Foo177: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar177
    }

    let bar177: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar177 = try container.decode(String.self, forKey: .bar177)
    }
}

struct Foo178: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar178
    }

    let bar178: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar178 = try container.decode(String.self, forKey: .bar178)
    }
}

struct Foo179: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar179
    }

    let bar179: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar179 = try container.decode(String.self, forKey: .bar179)
    }
}

struct Foo180: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar180
    }

    let bar180: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar180 = try container.decode(String.self, forKey: .bar180)
    }
}

struct Foo181: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar181
    }

    let bar181: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar181 = try container.decode(String.self, forKey: .bar181)
    }
}

struct Foo182: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar182
    }

    let bar182: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar182 = try container.decode(String.self, forKey: .bar182)
    }
}

struct Foo183: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar183
    }

    let bar183: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar183 = try container.decode(String.self, forKey: .bar183)
    }
}

struct Foo184: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar184
    }

    let bar184: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar184 = try container.decode(String.self, forKey: .bar184)
    }
}

struct Foo185: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar185
    }

    let bar185: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar185 = try container.decode(String.self, forKey: .bar185)
    }
}

struct Foo186: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar186
    }

    let bar186: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar186 = try container.decode(String.self, forKey: .bar186)
    }
}

struct Foo187: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar187
    }

    let bar187: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar187 = try container.decode(String.self, forKey: .bar187)
    }
}

struct Foo188: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar188
    }

    let bar188: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar188 = try container.decode(String.self, forKey: .bar188)
    }
}

struct Foo189: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar189
    }

    let bar189: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar189 = try container.decode(String.self, forKey: .bar189)
    }
}

struct Foo190: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar190
    }

    let bar190: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar190 = try container.decode(String.self, forKey: .bar190)
    }
}

struct Foo191: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar191
    }

    let bar191: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar191 = try container.decode(String.self, forKey: .bar191)
    }
}

struct Foo192: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar192
    }

    let bar192: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar192 = try container.decode(String.self, forKey: .bar192)
    }
}

struct Foo193: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar193
    }

    let bar193: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar193 = try container.decode(String.self, forKey: .bar193)
    }
}

struct Foo194: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar194
    }

    let bar194: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar194 = try container.decode(String.self, forKey: .bar194)
    }
}

struct Foo195: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar195
    }

    let bar195: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar195 = try container.decode(String.self, forKey: .bar195)
    }
}

struct Foo196: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar196
    }

    let bar196: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar196 = try container.decode(String.self, forKey: .bar196)
    }
}

struct Foo197: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar197
    }

    let bar197: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar197 = try container.decode(String.self, forKey: .bar197)
    }
}

struct Foo198: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar198
    }

    let bar198: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar198 = try container.decode(String.self, forKey: .bar198)
    }
}

struct Foo199: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar199
    }

    let bar199: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar199 = try container.decode(String.self, forKey: .bar199)
    }
}

struct Foo200: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar200
    }

    let bar200: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar200 = try container.decode(String.self, forKey: .bar200)
    }
}

struct Foo201: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar201
    }

    let bar201: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar201 = try container.decode(String.self, forKey: .bar201)
    }
}

struct Foo202: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar202
    }

    let bar202: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar202 = try container.decode(String.self, forKey: .bar202)
    }
}

struct Foo203: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar203
    }

    let bar203: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar203 = try container.decode(String.self, forKey: .bar203)
    }
}

struct Foo204: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar204
    }

    let bar204: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar204 = try container.decode(String.self, forKey: .bar204)
    }
}

struct Foo205: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar205
    }

    let bar205: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar205 = try container.decode(String.self, forKey: .bar205)
    }
}

struct Foo206: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar206
    }

    let bar206: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar206 = try container.decode(String.self, forKey: .bar206)
    }
}

struct Foo207: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar207
    }

    let bar207: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar207 = try container.decode(String.self, forKey: .bar207)
    }
}

struct Foo208: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar208
    }

    let bar208: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar208 = try container.decode(String.self, forKey: .bar208)
    }
}

struct Foo209: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar209
    }

    let bar209: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar209 = try container.decode(String.self, forKey: .bar209)
    }
}

struct Foo210: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar210
    }

    let bar210: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar210 = try container.decode(String.self, forKey: .bar210)
    }
}

struct Foo211: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar211
    }

    let bar211: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar211 = try container.decode(String.self, forKey: .bar211)
    }
}

struct Foo212: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar212
    }

    let bar212: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar212 = try container.decode(String.self, forKey: .bar212)
    }
}

struct Foo213: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar213
    }

    let bar213: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar213 = try container.decode(String.self, forKey: .bar213)
    }
}

struct Foo214: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar214
    }

    let bar214: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar214 = try container.decode(String.self, forKey: .bar214)
    }
}

struct Foo215: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar215
    }

    let bar215: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar215 = try container.decode(String.self, forKey: .bar215)
    }
}

struct Foo216: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar216
    }

    let bar216: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar216 = try container.decode(String.self, forKey: .bar216)
    }
}

struct Foo217: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar217
    }

    let bar217: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar217 = try container.decode(String.self, forKey: .bar217)
    }
}

struct Foo218: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar218
    }

    let bar218: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar218 = try container.decode(String.self, forKey: .bar218)
    }
}

struct Foo219: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar219
    }

    let bar219: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar219 = try container.decode(String.self, forKey: .bar219)
    }
}

struct Foo220: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar220
    }

    let bar220: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar220 = try container.decode(String.self, forKey: .bar220)
    }
}

struct Foo221: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar221
    }

    let bar221: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar221 = try container.decode(String.self, forKey: .bar221)
    }
}

struct Foo222: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar222
    }

    let bar222: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar222 = try container.decode(String.self, forKey: .bar222)
    }
}

struct Foo223: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar223
    }

    let bar223: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar223 = try container.decode(String.self, forKey: .bar223)
    }
}

struct Foo224: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar224
    }

    let bar224: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar224 = try container.decode(String.self, forKey: .bar224)
    }
}

struct Foo225: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar225
    }

    let bar225: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar225 = try container.decode(String.self, forKey: .bar225)
    }
}

struct Foo226: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar226
    }

    let bar226: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar226 = try container.decode(String.self, forKey: .bar226)
    }
}

struct Foo227: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar227
    }

    let bar227: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar227 = try container.decode(String.self, forKey: .bar227)
    }
}

struct Foo228: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar228
    }

    let bar228: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar228 = try container.decode(String.self, forKey: .bar228)
    }
}

struct Foo229: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar229
    }

    let bar229: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar229 = try container.decode(String.self, forKey: .bar229)
    }
}

struct Foo230: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar230
    }

    let bar230: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar230 = try container.decode(String.self, forKey: .bar230)
    }
}

struct Foo231: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar231
    }

    let bar231: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar231 = try container.decode(String.self, forKey: .bar231)
    }
}

struct Foo232: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar232
    }

    let bar232: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar232 = try container.decode(String.self, forKey: .bar232)
    }
}

struct Foo233: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar233
    }

    let bar233: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar233 = try container.decode(String.self, forKey: .bar233)
    }
}

struct Foo234: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar234
    }

    let bar234: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar234 = try container.decode(String.self, forKey: .bar234)
    }
}

struct Foo235: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar235
    }

    let bar235: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar235 = try container.decode(String.self, forKey: .bar235)
    }
}

struct Foo236: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar236
    }

    let bar236: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar236 = try container.decode(String.self, forKey: .bar236)
    }
}

struct Foo237: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar237
    }

    let bar237: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar237 = try container.decode(String.self, forKey: .bar237)
    }
}

struct Foo238: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar238
    }

    let bar238: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar238 = try container.decode(String.self, forKey: .bar238)
    }
}

struct Foo239: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar239
    }

    let bar239: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar239 = try container.decode(String.self, forKey: .bar239)
    }
}

struct Foo240: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar240
    }

    let bar240: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar240 = try container.decode(String.self, forKey: .bar240)
    }
}

struct Foo241: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar241
    }

    let bar241: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar241 = try container.decode(String.self, forKey: .bar241)
    }
}

struct Foo242: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar242
    }

    let bar242: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar242 = try container.decode(String.self, forKey: .bar242)
    }
}

struct Foo243: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar243
    }

    let bar243: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar243 = try container.decode(String.self, forKey: .bar243)
    }
}

struct Foo244: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar244
    }

    let bar244: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar244 = try container.decode(String.self, forKey: .bar244)
    }
}

struct Foo245: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar245
    }

    let bar245: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar245 = try container.decode(String.self, forKey: .bar245)
    }
}

struct Foo246: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar246
    }

    let bar246: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar246 = try container.decode(String.self, forKey: .bar246)
    }
}

struct Foo247: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar247
    }

    let bar247: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar247 = try container.decode(String.self, forKey: .bar247)
    }
}

struct Foo248: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar248
    }

    let bar248: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar248 = try container.decode(String.self, forKey: .bar248)
    }
}

struct Foo249: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar249
    }

    let bar249: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar249 = try container.decode(String.self, forKey: .bar249)
    }
}

struct Foo250: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar250
    }

    let bar250: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar250 = try container.decode(String.self, forKey: .bar250)
    }
}

struct Foo251: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar251
    }

    let bar251: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar251 = try container.decode(String.self, forKey: .bar251)
    }
}

struct Foo252: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar252
    }

    let bar252: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar252 = try container.decode(String.self, forKey: .bar252)
    }
}

struct Foo253: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar253
    }

    let bar253: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar253 = try container.decode(String.self, forKey: .bar253)
    }
}

struct Foo254: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar254
    }

    let bar254: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar254 = try container.decode(String.self, forKey: .bar254)
    }
}

struct Foo255: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar255
    }

    let bar255: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar255 = try container.decode(String.self, forKey: .bar255)
    }
}

struct Foo256: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar256
    }

    let bar256: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar256 = try container.decode(String.self, forKey: .bar256)
    }
}

struct Foo257: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar257
    }

    let bar257: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar257 = try container.decode(String.self, forKey: .bar257)
    }
}

struct Foo258: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar258
    }

    let bar258: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar258 = try container.decode(String.self, forKey: .bar258)
    }
}

struct Foo259: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar259
    }

    let bar259: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar259 = try container.decode(String.self, forKey: .bar259)
    }
}

struct Foo260: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar260
    }

    let bar260: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar260 = try container.decode(String.self, forKey: .bar260)
    }
}

struct Foo261: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar261
    }

    let bar261: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar261 = try container.decode(String.self, forKey: .bar261)
    }
}

struct Foo262: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar262
    }

    let bar262: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar262 = try container.decode(String.self, forKey: .bar262)
    }
}

struct Foo263: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar263
    }

    let bar263: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar263 = try container.decode(String.self, forKey: .bar263)
    }
}

struct Foo264: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar264
    }

    let bar264: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar264 = try container.decode(String.self, forKey: .bar264)
    }
}

struct Foo265: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar265
    }

    let bar265: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar265 = try container.decode(String.self, forKey: .bar265)
    }
}

struct Foo266: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar266
    }

    let bar266: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar266 = try container.decode(String.self, forKey: .bar266)
    }
}

struct Foo267: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar267
    }

    let bar267: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar267 = try container.decode(String.self, forKey: .bar267)
    }
}

struct Foo268: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar268
    }

    let bar268: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar268 = try container.decode(String.self, forKey: .bar268)
    }
}

struct Foo269: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar269
    }

    let bar269: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar269 = try container.decode(String.self, forKey: .bar269)
    }
}

struct Foo270: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar270
    }

    let bar270: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar270 = try container.decode(String.self, forKey: .bar270)
    }
}

struct Foo271: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar271
    }

    let bar271: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar271 = try container.decode(String.self, forKey: .bar271)
    }
}

struct Foo272: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar272
    }

    let bar272: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar272 = try container.decode(String.self, forKey: .bar272)
    }
}

struct Foo273: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar273
    }

    let bar273: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar273 = try container.decode(String.self, forKey: .bar273)
    }
}

struct Foo274: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar274
    }

    let bar274: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar274 = try container.decode(String.self, forKey: .bar274)
    }
}

struct Foo275: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar275
    }

    let bar275: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar275 = try container.decode(String.self, forKey: .bar275)
    }
}

struct Foo276: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar276
    }

    let bar276: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar276 = try container.decode(String.self, forKey: .bar276)
    }
}

struct Foo277: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar277
    }

    let bar277: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar277 = try container.decode(String.self, forKey: .bar277)
    }
}

struct Foo278: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar278
    }

    let bar278: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar278 = try container.decode(String.self, forKey: .bar278)
    }
}

struct Foo279: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar279
    }

    let bar279: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar279 = try container.decode(String.self, forKey: .bar279)
    }
}

struct Foo280: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar280
    }

    let bar280: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar280 = try container.decode(String.self, forKey: .bar280)
    }
}

struct Foo281: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar281
    }

    let bar281: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar281 = try container.decode(String.self, forKey: .bar281)
    }
}

struct Foo282: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar282
    }

    let bar282: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar282 = try container.decode(String.self, forKey: .bar282)
    }
}

struct Foo283: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar283
    }

    let bar283: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar283 = try container.decode(String.self, forKey: .bar283)
    }
}

struct Foo284: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar284
    }

    let bar284: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar284 = try container.decode(String.self, forKey: .bar284)
    }
}

struct Foo285: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar285
    }

    let bar285: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar285 = try container.decode(String.self, forKey: .bar285)
    }
}

struct Foo286: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar286
    }

    let bar286: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar286 = try container.decode(String.self, forKey: .bar286)
    }
}

struct Foo287: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar287
    }

    let bar287: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar287 = try container.decode(String.self, forKey: .bar287)
    }
}

struct Foo288: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar288
    }

    let bar288: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar288 = try container.decode(String.self, forKey: .bar288)
    }
}

struct Foo289: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar289
    }

    let bar289: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar289 = try container.decode(String.self, forKey: .bar289)
    }
}

struct Foo290: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar290
    }

    let bar290: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar290 = try container.decode(String.self, forKey: .bar290)
    }
}

struct Foo291: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar291
    }

    let bar291: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar291 = try container.decode(String.self, forKey: .bar291)
    }
}

struct Foo292: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar292
    }

    let bar292: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar292 = try container.decode(String.self, forKey: .bar292)
    }
}

struct Foo293: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar293
    }

    let bar293: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar293 = try container.decode(String.self, forKey: .bar293)
    }
}

struct Foo294: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar294
    }

    let bar294: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar294 = try container.decode(String.self, forKey: .bar294)
    }
}

struct Foo295: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar295
    }

    let bar295: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar295 = try container.decode(String.self, forKey: .bar295)
    }
}

struct Foo296: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar296
    }

    let bar296: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar296 = try container.decode(String.self, forKey: .bar296)
    }
}

struct Foo297: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar297
    }

    let bar297: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar297 = try container.decode(String.self, forKey: .bar297)
    }
}

struct Foo298: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar298
    }

    let bar298: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar298 = try container.decode(String.self, forKey: .bar298)
    }
}

struct Foo299: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar299
    }

    let bar299: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar299 = try container.decode(String.self, forKey: .bar299)
    }
}

struct Foo300: Decodable {
    enum CodingKeys: String, CodingKey {
        case bar300
    }

    let bar300: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.bar300 = try container.decode(String.self, forKey: .bar300)
    }
}

Source for `StringCodingKey`

import Foundation

struct StringCodingKey: CodingKey, ExpressibleByStringLiteral {
    private let string: String
    private var int: Int?

    var stringValue: String { return string }

    init(string: String) {
        self.string = string
    }

    init?(stringValue: String) {
        self.string = stringValue
    }

    var intValue: Int? { return int }

    init?(intValue: Int) {
        self.string = String(describing: intValue)
        self.int = intValue
    }

    init(stringLiteral value: String) {
        self.string = value
    }
}

struct Foo1: Decodable {
    let bar1: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar1 = try container.decode(String.self, forKey: "bar1")
    }
}

struct Foo2: Decodable {
    let bar2: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar2 = try container.decode(String.self, forKey: "bar2")
    }
}

struct Foo3: Decodable {
    let bar3: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar3 = try container.decode(String.self, forKey: "bar3")
    }
}

struct Foo4: Decodable {
    let bar4: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar4 = try container.decode(String.self, forKey: "bar4")
    }
}

struct Foo5: Decodable {
    let bar5: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar5 = try container.decode(String.self, forKey: "bar5")
    }
}

struct Foo6: Decodable {
    let bar6: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar6 = try container.decode(String.self, forKey: "bar6")
    }
}

struct Foo7: Decodable {
    let bar7: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar7 = try container.decode(String.self, forKey: "bar7")
    }
}

struct Foo8: Decodable {
    let bar8: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar8 = try container.decode(String.self, forKey: "bar8")
    }
}

struct Foo9: Decodable {
    let bar9: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar9 = try container.decode(String.self, forKey: "bar9")
    }
}

struct Foo10: Decodable {
    let bar10: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar10 = try container.decode(String.self, forKey: "bar10")
    }
}

struct Foo11: Decodable {
    let bar11: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar11 = try container.decode(String.self, forKey: "bar11")
    }
}

struct Foo12: Decodable {
    let bar12: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar12 = try container.decode(String.self, forKey: "bar12")
    }
}

struct Foo13: Decodable {
    let bar13: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar13 = try container.decode(String.self, forKey: "bar13")
    }
}

struct Foo14: Decodable {
    let bar14: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar14 = try container.decode(String.self, forKey: "bar14")
    }
}

struct Foo15: Decodable {
    let bar15: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar15 = try container.decode(String.self, forKey: "bar15")
    }
}

struct Foo16: Decodable {
    let bar16: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar16 = try container.decode(String.self, forKey: "bar16")
    }
}

struct Foo17: Decodable {
    let bar17: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar17 = try container.decode(String.self, forKey: "bar17")
    }
}

struct Foo18: Decodable {
    let bar18: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar18 = try container.decode(String.self, forKey: "bar18")
    }
}

struct Foo19: Decodable {
    let bar19: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar19 = try container.decode(String.self, forKey: "bar19")
    }
}

struct Foo20: Decodable {
    let bar20: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar20 = try container.decode(String.self, forKey: "bar20")
    }
}

struct Foo21: Decodable {
    let bar21: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar21 = try container.decode(String.self, forKey: "bar21")
    }
}

struct Foo22: Decodable {
    let bar22: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar22 = try container.decode(String.self, forKey: "bar22")
    }
}

struct Foo23: Decodable {
    let bar23: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar23 = try container.decode(String.self, forKey: "bar23")
    }
}

struct Foo24: Decodable {
    let bar24: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar24 = try container.decode(String.self, forKey: "bar24")
    }
}

struct Foo25: Decodable {
    let bar25: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar25 = try container.decode(String.self, forKey: "bar25")
    }
}

struct Foo26: Decodable {
    let bar26: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar26 = try container.decode(String.self, forKey: "bar26")
    }
}

struct Foo27: Decodable {
    let bar27: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar27 = try container.decode(String.self, forKey: "bar27")
    }
}

struct Foo28: Decodable {
    let bar28: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar28 = try container.decode(String.self, forKey: "bar28")
    }
}

struct Foo29: Decodable {
    let bar29: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar29 = try container.decode(String.self, forKey: "bar29")
    }
}

struct Foo30: Decodable {
    let bar30: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar30 = try container.decode(String.self, forKey: "bar30")
    }
}

struct Foo31: Decodable {
    let bar31: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar31 = try container.decode(String.self, forKey: "bar31")
    }
}

struct Foo32: Decodable {
    let bar32: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar32 = try container.decode(String.self, forKey: "bar32")
    }
}

struct Foo33: Decodable {
    let bar33: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar33 = try container.decode(String.self, forKey: "bar33")
    }
}

struct Foo34: Decodable {
    let bar34: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar34 = try container.decode(String.self, forKey: "bar34")
    }
}

struct Foo35: Decodable {
    let bar35: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar35 = try container.decode(String.self, forKey: "bar35")
    }
}

struct Foo36: Decodable {
    let bar36: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar36 = try container.decode(String.self, forKey: "bar36")
    }
}

struct Foo37: Decodable {
    let bar37: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar37 = try container.decode(String.self, forKey: "bar37")
    }
}

struct Foo38: Decodable {
    let bar38: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar38 = try container.decode(String.self, forKey: "bar38")
    }
}

struct Foo39: Decodable {
    let bar39: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar39 = try container.decode(String.self, forKey: "bar39")
    }
}

struct Foo40: Decodable {
    let bar40: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar40 = try container.decode(String.self, forKey: "bar40")
    }
}

struct Foo41: Decodable {
    let bar41: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar41 = try container.decode(String.self, forKey: "bar41")
    }
}

struct Foo42: Decodable {
    let bar42: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar42 = try container.decode(String.self, forKey: "bar42")
    }
}

struct Foo43: Decodable {
    let bar43: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar43 = try container.decode(String.self, forKey: "bar43")
    }
}

struct Foo44: Decodable {
    let bar44: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar44 = try container.decode(String.self, forKey: "bar44")
    }
}

struct Foo45: Decodable {
    let bar45: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar45 = try container.decode(String.self, forKey: "bar45")
    }
}

struct Foo46: Decodable {
    let bar46: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar46 = try container.decode(String.self, forKey: "bar46")
    }
}

struct Foo47: Decodable {
    let bar47: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar47 = try container.decode(String.self, forKey: "bar47")
    }
}

struct Foo48: Decodable {
    let bar48: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar48 = try container.decode(String.self, forKey: "bar48")
    }
}

struct Foo49: Decodable {
    let bar49: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar49 = try container.decode(String.self, forKey: "bar49")
    }
}

struct Foo50: Decodable {
    let bar50: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar50 = try container.decode(String.self, forKey: "bar50")
    }
}

struct Foo51: Decodable {
    let bar51: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar51 = try container.decode(String.self, forKey: "bar51")
    }
}

struct Foo52: Decodable {
    let bar52: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar52 = try container.decode(String.self, forKey: "bar52")
    }
}

struct Foo53: Decodable {
    let bar53: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar53 = try container.decode(String.self, forKey: "bar53")
    }
}

struct Foo54: Decodable {
    let bar54: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar54 = try container.decode(String.self, forKey: "bar54")
    }
}

struct Foo55: Decodable {
    let bar55: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar55 = try container.decode(String.self, forKey: "bar55")
    }
}

struct Foo56: Decodable {
    let bar56: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar56 = try container.decode(String.self, forKey: "bar56")
    }
}

struct Foo57: Decodable {
    let bar57: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar57 = try container.decode(String.self, forKey: "bar57")
    }
}

struct Foo58: Decodable {
    let bar58: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar58 = try container.decode(String.self, forKey: "bar58")
    }
}

struct Foo59: Decodable {
    let bar59: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar59 = try container.decode(String.self, forKey: "bar59")
    }
}

struct Foo60: Decodable {
    let bar60: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar60 = try container.decode(String.self, forKey: "bar60")
    }
}

struct Foo61: Decodable {
    let bar61: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar61 = try container.decode(String.self, forKey: "bar61")
    }
}

struct Foo62: Decodable {
    let bar62: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar62 = try container.decode(String.self, forKey: "bar62")
    }
}

struct Foo63: Decodable {
    let bar63: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar63 = try container.decode(String.self, forKey: "bar63")
    }
}

struct Foo64: Decodable {
    let bar64: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar64 = try container.decode(String.self, forKey: "bar64")
    }
}

struct Foo65: Decodable {
    let bar65: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar65 = try container.decode(String.self, forKey: "bar65")
    }
}

struct Foo66: Decodable {
    let bar66: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar66 = try container.decode(String.self, forKey: "bar66")
    }
}

struct Foo67: Decodable {
    let bar67: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar67 = try container.decode(String.self, forKey: "bar67")
    }
}

struct Foo68: Decodable {
    let bar68: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar68 = try container.decode(String.self, forKey: "bar68")
    }
}

struct Foo69: Decodable {
    let bar69: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar69 = try container.decode(String.self, forKey: "bar69")
    }
}

struct Foo70: Decodable {
    let bar70: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar70 = try container.decode(String.self, forKey: "bar70")
    }
}

struct Foo71: Decodable {
    let bar71: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar71 = try container.decode(String.self, forKey: "bar71")
    }
}

struct Foo72: Decodable {
    let bar72: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar72 = try container.decode(String.self, forKey: "bar72")
    }
}

struct Foo73: Decodable {
    let bar73: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar73 = try container.decode(String.self, forKey: "bar73")
    }
}

struct Foo74: Decodable {
    let bar74: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar74 = try container.decode(String.self, forKey: "bar74")
    }
}

struct Foo75: Decodable {
    let bar75: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar75 = try container.decode(String.self, forKey: "bar75")
    }
}

struct Foo76: Decodable {
    let bar76: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar76 = try container.decode(String.self, forKey: "bar76")
    }
}

struct Foo77: Decodable {
    let bar77: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar77 = try container.decode(String.self, forKey: "bar77")
    }
}

struct Foo78: Decodable {
    let bar78: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar78 = try container.decode(String.self, forKey: "bar78")
    }
}

struct Foo79: Decodable {
    let bar79: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar79 = try container.decode(String.self, forKey: "bar79")
    }
}

struct Foo80: Decodable {
    let bar80: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar80 = try container.decode(String.self, forKey: "bar80")
    }
}

struct Foo81: Decodable {
    let bar81: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar81 = try container.decode(String.self, forKey: "bar81")
    }
}

struct Foo82: Decodable {
    let bar82: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar82 = try container.decode(String.self, forKey: "bar82")
    }
}

struct Foo83: Decodable {
    let bar83: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar83 = try container.decode(String.self, forKey: "bar83")
    }
}

struct Foo84: Decodable {
    let bar84: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar84 = try container.decode(String.self, forKey: "bar84")
    }
}

struct Foo85: Decodable {
    let bar85: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar85 = try container.decode(String.self, forKey: "bar85")
    }
}

struct Foo86: Decodable {
    let bar86: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar86 = try container.decode(String.self, forKey: "bar86")
    }
}

struct Foo87: Decodable {
    let bar87: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar87 = try container.decode(String.self, forKey: "bar87")
    }
}

struct Foo88: Decodable {
    let bar88: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar88 = try container.decode(String.self, forKey: "bar88")
    }
}

struct Foo89: Decodable {
    let bar89: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar89 = try container.decode(String.self, forKey: "bar89")
    }
}

struct Foo90: Decodable {
    let bar90: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar90 = try container.decode(String.self, forKey: "bar90")
    }
}

struct Foo91: Decodable {
    let bar91: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar91 = try container.decode(String.self, forKey: "bar91")
    }
}

struct Foo92: Decodable {
    let bar92: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar92 = try container.decode(String.self, forKey: "bar92")
    }
}

struct Foo93: Decodable {
    let bar93: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar93 = try container.decode(String.self, forKey: "bar93")
    }
}

struct Foo94: Decodable {
    let bar94: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar94 = try container.decode(String.self, forKey: "bar94")
    }
}

struct Foo95: Decodable {
    let bar95: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar95 = try container.decode(String.self, forKey: "bar95")
    }
}

struct Foo96: Decodable {
    let bar96: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar96 = try container.decode(String.self, forKey: "bar96")
    }
}

struct Foo97: Decodable {
    let bar97: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar97 = try container.decode(String.self, forKey: "bar97")
    }
}

struct Foo98: Decodable {
    let bar98: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar98 = try container.decode(String.self, forKey: "bar98")
    }
}

struct Foo99: Decodable {
    let bar99: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar99 = try container.decode(String.self, forKey: "bar99")
    }
}

struct Foo100: Decodable {
    let bar100: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar100 = try container.decode(String.self, forKey: "bar100")
    }
}

struct Foo101: Decodable {
    let bar101: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar101 = try container.decode(String.self, forKey: "bar101")
    }
}

struct Foo102: Decodable {
    let bar102: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar102 = try container.decode(String.self, forKey: "bar102")
    }
}

struct Foo103: Decodable {
    let bar103: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar103 = try container.decode(String.self, forKey: "bar103")
    }
}

struct Foo104: Decodable {
    let bar104: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar104 = try container.decode(String.self, forKey: "bar104")
    }
}

struct Foo105: Decodable {
    let bar105: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar105 = try container.decode(String.self, forKey: "bar105")
    }
}

struct Foo106: Decodable {
    let bar106: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar106 = try container.decode(String.self, forKey: "bar106")
    }
}

struct Foo107: Decodable {
    let bar107: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar107 = try container.decode(String.self, forKey: "bar107")
    }
}

struct Foo108: Decodable {
    let bar108: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar108 = try container.decode(String.self, forKey: "bar108")
    }
}

struct Foo109: Decodable {
    let bar109: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar109 = try container.decode(String.self, forKey: "bar109")
    }
}

struct Foo110: Decodable {
    let bar110: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar110 = try container.decode(String.self, forKey: "bar110")
    }
}

struct Foo111: Decodable {
    let bar111: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar111 = try container.decode(String.self, forKey: "bar111")
    }
}

struct Foo112: Decodable {
    let bar112: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar112 = try container.decode(String.self, forKey: "bar112")
    }
}

struct Foo113: Decodable {
    let bar113: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar113 = try container.decode(String.self, forKey: "bar113")
    }
}

struct Foo114: Decodable {
    let bar114: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar114 = try container.decode(String.self, forKey: "bar114")
    }
}

struct Foo115: Decodable {
    let bar115: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar115 = try container.decode(String.self, forKey: "bar115")
    }
}

struct Foo116: Decodable {
    let bar116: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar116 = try container.decode(String.self, forKey: "bar116")
    }
}

struct Foo117: Decodable {
    let bar117: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar117 = try container.decode(String.self, forKey: "bar117")
    }
}

struct Foo118: Decodable {
    let bar118: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar118 = try container.decode(String.self, forKey: "bar118")
    }
}

struct Foo119: Decodable {
    let bar119: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar119 = try container.decode(String.self, forKey: "bar119")
    }
}

struct Foo120: Decodable {
    let bar120: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar120 = try container.decode(String.self, forKey: "bar120")
    }
}

struct Foo121: Decodable {
    let bar121: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar121 = try container.decode(String.self, forKey: "bar121")
    }
}

struct Foo122: Decodable {
    let bar122: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar122 = try container.decode(String.self, forKey: "bar122")
    }
}

struct Foo123: Decodable {
    let bar123: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar123 = try container.decode(String.self, forKey: "bar123")
    }
}

struct Foo124: Decodable {
    let bar124: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar124 = try container.decode(String.self, forKey: "bar124")
    }
}

struct Foo125: Decodable {
    let bar125: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar125 = try container.decode(String.self, forKey: "bar125")
    }
}

struct Foo126: Decodable {
    let bar126: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar126 = try container.decode(String.self, forKey: "bar126")
    }
}

struct Foo127: Decodable {
    let bar127: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar127 = try container.decode(String.self, forKey: "bar127")
    }
}

struct Foo128: Decodable {
    let bar128: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar128 = try container.decode(String.self, forKey: "bar128")
    }
}

struct Foo129: Decodable {
    let bar129: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar129 = try container.decode(String.self, forKey: "bar129")
    }
}

struct Foo130: Decodable {
    let bar130: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar130 = try container.decode(String.self, forKey: "bar130")
    }
}

struct Foo131: Decodable {
    let bar131: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar131 = try container.decode(String.self, forKey: "bar131")
    }
}

struct Foo132: Decodable {
    let bar132: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar132 = try container.decode(String.self, forKey: "bar132")
    }
}

struct Foo133: Decodable {
    let bar133: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar133 = try container.decode(String.self, forKey: "bar133")
    }
}

struct Foo134: Decodable {
    let bar134: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar134 = try container.decode(String.self, forKey: "bar134")
    }
}

struct Foo135: Decodable {
    let bar135: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar135 = try container.decode(String.self, forKey: "bar135")
    }
}

struct Foo136: Decodable {
    let bar136: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar136 = try container.decode(String.self, forKey: "bar136")
    }
}

struct Foo137: Decodable {
    let bar137: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar137 = try container.decode(String.self, forKey: "bar137")
    }
}

struct Foo138: Decodable {
    let bar138: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar138 = try container.decode(String.self, forKey: "bar138")
    }
}

struct Foo139: Decodable {
    let bar139: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar139 = try container.decode(String.self, forKey: "bar139")
    }
}

struct Foo140: Decodable {
    let bar140: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar140 = try container.decode(String.self, forKey: "bar140")
    }
}

struct Foo141: Decodable {
    let bar141: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar141 = try container.decode(String.self, forKey: "bar141")
    }
}

struct Foo142: Decodable {
    let bar142: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar142 = try container.decode(String.self, forKey: "bar142")
    }
}

struct Foo143: Decodable {
    let bar143: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar143 = try container.decode(String.self, forKey: "bar143")
    }
}

struct Foo144: Decodable {
    let bar144: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar144 = try container.decode(String.self, forKey: "bar144")
    }
}

struct Foo145: Decodable {
    let bar145: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar145 = try container.decode(String.self, forKey: "bar145")
    }
}

struct Foo146: Decodable {
    let bar146: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar146 = try container.decode(String.self, forKey: "bar146")
    }
}

struct Foo147: Decodable {
    let bar147: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar147 = try container.decode(String.self, forKey: "bar147")
    }
}

struct Foo148: Decodable {
    let bar148: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar148 = try container.decode(String.self, forKey: "bar148")
    }
}

struct Foo149: Decodable {
    let bar149: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar149 = try container.decode(String.self, forKey: "bar149")
    }
}

struct Foo150: Decodable {
    let bar150: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar150 = try container.decode(String.self, forKey: "bar150")
    }
}

struct Foo151: Decodable {
    let bar151: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar151 = try container.decode(String.self, forKey: "bar151")
    }
}

struct Foo152: Decodable {
    let bar152: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar152 = try container.decode(String.self, forKey: "bar152")
    }
}

struct Foo153: Decodable {
    let bar153: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar153 = try container.decode(String.self, forKey: "bar153")
    }
}

struct Foo154: Decodable {
    let bar154: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar154 = try container.decode(String.self, forKey: "bar154")
    }
}

struct Foo155: Decodable {
    let bar155: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar155 = try container.decode(String.self, forKey: "bar155")
    }
}

struct Foo156: Decodable {
    let bar156: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar156 = try container.decode(String.self, forKey: "bar156")
    }
}

struct Foo157: Decodable {
    let bar157: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar157 = try container.decode(String.self, forKey: "bar157")
    }
}

struct Foo158: Decodable {
    let bar158: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar158 = try container.decode(String.self, forKey: "bar158")
    }
}

struct Foo159: Decodable {
    let bar159: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar159 = try container.decode(String.self, forKey: "bar159")
    }
}

struct Foo160: Decodable {
    let bar160: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar160 = try container.decode(String.self, forKey: "bar160")
    }
}

struct Foo161: Decodable {
    let bar161: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar161 = try container.decode(String.self, forKey: "bar161")
    }
}

struct Foo162: Decodable {
    let bar162: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar162 = try container.decode(String.self, forKey: "bar162")
    }
}

struct Foo163: Decodable {
    let bar163: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar163 = try container.decode(String.self, forKey: "bar163")
    }
}

struct Foo164: Decodable {
    let bar164: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar164 = try container.decode(String.self, forKey: "bar164")
    }
}

struct Foo165: Decodable {
    let bar165: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar165 = try container.decode(String.self, forKey: "bar165")
    }
}

struct Foo166: Decodable {
    let bar166: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar166 = try container.decode(String.self, forKey: "bar166")
    }
}

struct Foo167: Decodable {
    let bar167: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar167 = try container.decode(String.self, forKey: "bar167")
    }
}

struct Foo168: Decodable {
    let bar168: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar168 = try container.decode(String.self, forKey: "bar168")
    }
}

struct Foo169: Decodable {
    let bar169: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar169 = try container.decode(String.self, forKey: "bar169")
    }
}

struct Foo170: Decodable {
    let bar170: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar170 = try container.decode(String.self, forKey: "bar170")
    }
}

struct Foo171: Decodable {
    let bar171: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar171 = try container.decode(String.self, forKey: "bar171")
    }
}

struct Foo172: Decodable {
    let bar172: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar172 = try container.decode(String.self, forKey: "bar172")
    }
}

struct Foo173: Decodable {
    let bar173: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar173 = try container.decode(String.self, forKey: "bar173")
    }
}

struct Foo174: Decodable {
    let bar174: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar174 = try container.decode(String.self, forKey: "bar174")
    }
}

struct Foo175: Decodable {
    let bar175: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar175 = try container.decode(String.self, forKey: "bar175")
    }
}

struct Foo176: Decodable {
    let bar176: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar176 = try container.decode(String.self, forKey: "bar176")
    }
}

struct Foo177: Decodable {
    let bar177: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar177 = try container.decode(String.self, forKey: "bar177")
    }
}

struct Foo178: Decodable {
    let bar178: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar178 = try container.decode(String.self, forKey: "bar178")
    }
}

struct Foo179: Decodable {
    let bar179: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar179 = try container.decode(String.self, forKey: "bar179")
    }
}

struct Foo180: Decodable {
    let bar180: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar180 = try container.decode(String.self, forKey: "bar180")
    }
}

struct Foo181: Decodable {
    let bar181: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar181 = try container.decode(String.self, forKey: "bar181")
    }
}

struct Foo182: Decodable {
    let bar182: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar182 = try container.decode(String.self, forKey: "bar182")
    }
}

struct Foo183: Decodable {
    let bar183: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar183 = try container.decode(String.self, forKey: "bar183")
    }
}

struct Foo184: Decodable {
    let bar184: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar184 = try container.decode(String.self, forKey: "bar184")
    }
}

struct Foo185: Decodable {
    let bar185: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar185 = try container.decode(String.self, forKey: "bar185")
    }
}

struct Foo186: Decodable {
    let bar186: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar186 = try container.decode(String.self, forKey: "bar186")
    }
}

struct Foo187: Decodable {
    let bar187: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar187 = try container.decode(String.self, forKey: "bar187")
    }
}

struct Foo188: Decodable {
    let bar188: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar188 = try container.decode(String.self, forKey: "bar188")
    }
}

struct Foo189: Decodable {
    let bar189: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar189 = try container.decode(String.self, forKey: "bar189")
    }
}

struct Foo190: Decodable {
    let bar190: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar190 = try container.decode(String.self, forKey: "bar190")
    }
}

struct Foo191: Decodable {
    let bar191: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar191 = try container.decode(String.self, forKey: "bar191")
    }
}

struct Foo192: Decodable {
    let bar192: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar192 = try container.decode(String.self, forKey: "bar192")
    }
}

struct Foo193: Decodable {
    let bar193: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar193 = try container.decode(String.self, forKey: "bar193")
    }
}

struct Foo194: Decodable {
    let bar194: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar194 = try container.decode(String.self, forKey: "bar194")
    }
}

struct Foo195: Decodable {
    let bar195: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar195 = try container.decode(String.self, forKey: "bar195")
    }
}

struct Foo196: Decodable {
    let bar196: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar196 = try container.decode(String.self, forKey: "bar196")
    }
}

struct Foo197: Decodable {
    let bar197: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar197 = try container.decode(String.self, forKey: "bar197")
    }
}

struct Foo198: Decodable {
    let bar198: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar198 = try container.decode(String.self, forKey: "bar198")
    }
}

struct Foo199: Decodable {
    let bar199: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar199 = try container.decode(String.self, forKey: "bar199")
    }
}

struct Foo200: Decodable {
    let bar200: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar200 = try container.decode(String.self, forKey: "bar200")
    }
}

struct Foo201: Decodable {
    let bar201: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar201 = try container.decode(String.self, forKey: "bar201")
    }
}

struct Foo202: Decodable {
    let bar202: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar202 = try container.decode(String.self, forKey: "bar202")
    }
}

struct Foo203: Decodable {
    let bar203: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar203 = try container.decode(String.self, forKey: "bar203")
    }
}

struct Foo204: Decodable {
    let bar204: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar204 = try container.decode(String.self, forKey: "bar204")
    }
}

struct Foo205: Decodable {
    let bar205: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar205 = try container.decode(String.self, forKey: "bar205")
    }
}

struct Foo206: Decodable {
    let bar206: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar206 = try container.decode(String.self, forKey: "bar206")
    }
}

struct Foo207: Decodable {
    let bar207: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar207 = try container.decode(String.self, forKey: "bar207")
    }
}

struct Foo208: Decodable {
    let bar208: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar208 = try container.decode(String.self, forKey: "bar208")
    }
}

struct Foo209: Decodable {
    let bar209: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar209 = try container.decode(String.self, forKey: "bar209")
    }
}

struct Foo210: Decodable {
    let bar210: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar210 = try container.decode(String.self, forKey: "bar210")
    }
}

struct Foo211: Decodable {
    let bar211: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar211 = try container.decode(String.self, forKey: "bar211")
    }
}

struct Foo212: Decodable {
    let bar212: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar212 = try container.decode(String.self, forKey: "bar212")
    }
}

struct Foo213: Decodable {
    let bar213: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar213 = try container.decode(String.self, forKey: "bar213")
    }
}

struct Foo214: Decodable {
    let bar214: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar214 = try container.decode(String.self, forKey: "bar214")
    }
}

struct Foo215: Decodable {
    let bar215: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar215 = try container.decode(String.self, forKey: "bar215")
    }
}

struct Foo216: Decodable {
    let bar216: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar216 = try container.decode(String.self, forKey: "bar216")
    }
}

struct Foo217: Decodable {
    let bar217: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar217 = try container.decode(String.self, forKey: "bar217")
    }
}

struct Foo218: Decodable {
    let bar218: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar218 = try container.decode(String.self, forKey: "bar218")
    }
}

struct Foo219: Decodable {
    let bar219: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar219 = try container.decode(String.self, forKey: "bar219")
    }
}

struct Foo220: Decodable {
    let bar220: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar220 = try container.decode(String.self, forKey: "bar220")
    }
}

struct Foo221: Decodable {
    let bar221: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar221 = try container.decode(String.self, forKey: "bar221")
    }
}

struct Foo222: Decodable {
    let bar222: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar222 = try container.decode(String.self, forKey: "bar222")
    }
}

struct Foo223: Decodable {
    let bar223: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar223 = try container.decode(String.self, forKey: "bar223")
    }
}

struct Foo224: Decodable {
    let bar224: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar224 = try container.decode(String.self, forKey: "bar224")
    }
}

struct Foo225: Decodable {
    let bar225: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar225 = try container.decode(String.self, forKey: "bar225")
    }
}

struct Foo226: Decodable {
    let bar226: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar226 = try container.decode(String.self, forKey: "bar226")
    }
}

struct Foo227: Decodable {
    let bar227: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar227 = try container.decode(String.self, forKey: "bar227")
    }
}

struct Foo228: Decodable {
    let bar228: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar228 = try container.decode(String.self, forKey: "bar228")
    }
}

struct Foo229: Decodable {
    let bar229: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar229 = try container.decode(String.self, forKey: "bar229")
    }
}

struct Foo230: Decodable {
    let bar230: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar230 = try container.decode(String.self, forKey: "bar230")
    }
}

struct Foo231: Decodable {
    let bar231: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar231 = try container.decode(String.self, forKey: "bar231")
    }
}

struct Foo232: Decodable {
    let bar232: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar232 = try container.decode(String.self, forKey: "bar232")
    }
}

struct Foo233: Decodable {
    let bar233: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar233 = try container.decode(String.self, forKey: "bar233")
    }
}

struct Foo234: Decodable {
    let bar234: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar234 = try container.decode(String.self, forKey: "bar234")
    }
}

struct Foo235: Decodable {
    let bar235: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar235 = try container.decode(String.self, forKey: "bar235")
    }
}

struct Foo236: Decodable {
    let bar236: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar236 = try container.decode(String.self, forKey: "bar236")
    }
}

struct Foo237: Decodable {
    let bar237: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar237 = try container.decode(String.self, forKey: "bar237")
    }
}

struct Foo238: Decodable {
    let bar238: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar238 = try container.decode(String.self, forKey: "bar238")
    }
}

struct Foo239: Decodable {
    let bar239: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar239 = try container.decode(String.self, forKey: "bar239")
    }
}

struct Foo240: Decodable {
    let bar240: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar240 = try container.decode(String.self, forKey: "bar240")
    }
}

struct Foo241: Decodable {
    let bar241: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar241 = try container.decode(String.self, forKey: "bar241")
    }
}

struct Foo242: Decodable {
    let bar242: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar242 = try container.decode(String.self, forKey: "bar242")
    }
}

struct Foo243: Decodable {
    let bar243: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar243 = try container.decode(String.self, forKey: "bar243")
    }
}

struct Foo244: Decodable {
    let bar244: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar244 = try container.decode(String.self, forKey: "bar244")
    }
}

struct Foo245: Decodable {
    let bar245: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar245 = try container.decode(String.self, forKey: "bar245")
    }
}

struct Foo246: Decodable {
    let bar246: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar246 = try container.decode(String.self, forKey: "bar246")
    }
}

struct Foo247: Decodable {
    let bar247: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar247 = try container.decode(String.self, forKey: "bar247")
    }
}

struct Foo248: Decodable {
    let bar248: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar248 = try container.decode(String.self, forKey: "bar248")
    }
}

struct Foo249: Decodable {
    let bar249: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar249 = try container.decode(String.self, forKey: "bar249")
    }
}

struct Foo250: Decodable {
    let bar250: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar250 = try container.decode(String.self, forKey: "bar250")
    }
}

struct Foo251: Decodable {
    let bar251: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar251 = try container.decode(String.self, forKey: "bar251")
    }
}

struct Foo252: Decodable {
    let bar252: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar252 = try container.decode(String.self, forKey: "bar252")
    }
}

struct Foo253: Decodable {
    let bar253: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar253 = try container.decode(String.self, forKey: "bar253")
    }
}

struct Foo254: Decodable {
    let bar254: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar254 = try container.decode(String.self, forKey: "bar254")
    }
}

struct Foo255: Decodable {
    let bar255: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar255 = try container.decode(String.self, forKey: "bar255")
    }
}

struct Foo256: Decodable {
    let bar256: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar256 = try container.decode(String.self, forKey: "bar256")
    }
}

struct Foo257: Decodable {
    let bar257: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar257 = try container.decode(String.self, forKey: "bar257")
    }
}

struct Foo258: Decodable {
    let bar258: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar258 = try container.decode(String.self, forKey: "bar258")
    }
}

struct Foo259: Decodable {
    let bar259: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar259 = try container.decode(String.self, forKey: "bar259")
    }
}

struct Foo260: Decodable {
    let bar260: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar260 = try container.decode(String.self, forKey: "bar260")
    }
}

struct Foo261: Decodable {
    let bar261: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar261 = try container.decode(String.self, forKey: "bar261")
    }
}

struct Foo262: Decodable {
    let bar262: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar262 = try container.decode(String.self, forKey: "bar262")
    }
}

struct Foo263: Decodable {
    let bar263: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar263 = try container.decode(String.self, forKey: "bar263")
    }
}

struct Foo264: Decodable {
    let bar264: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar264 = try container.decode(String.self, forKey: "bar264")
    }
}

struct Foo265: Decodable {
    let bar265: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar265 = try container.decode(String.self, forKey: "bar265")
    }
}

struct Foo266: Decodable {
    let bar266: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar266 = try container.decode(String.self, forKey: "bar266")
    }
}

struct Foo267: Decodable {
    let bar267: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar267 = try container.decode(String.self, forKey: "bar267")
    }
}

struct Foo268: Decodable {
    let bar268: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar268 = try container.decode(String.self, forKey: "bar268")
    }
}

struct Foo269: Decodable {
    let bar269: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar269 = try container.decode(String.self, forKey: "bar269")
    }
}

struct Foo270: Decodable {
    let bar270: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar270 = try container.decode(String.self, forKey: "bar270")
    }
}

struct Foo271: Decodable {
    let bar271: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar271 = try container.decode(String.self, forKey: "bar271")
    }
}

struct Foo272: Decodable {
    let bar272: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar272 = try container.decode(String.self, forKey: "bar272")
    }
}

struct Foo273: Decodable {
    let bar273: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar273 = try container.decode(String.self, forKey: "bar273")
    }
}

struct Foo274: Decodable {
    let bar274: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar274 = try container.decode(String.self, forKey: "bar274")
    }
}

struct Foo275: Decodable {
    let bar275: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar275 = try container.decode(String.self, forKey: "bar275")
    }
}

struct Foo276: Decodable {
    let bar276: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar276 = try container.decode(String.self, forKey: "bar276")
    }
}

struct Foo277: Decodable {
    let bar277: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar277 = try container.decode(String.self, forKey: "bar277")
    }
}

struct Foo278: Decodable {
    let bar278: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar278 = try container.decode(String.self, forKey: "bar278")
    }
}

struct Foo279: Decodable {
    let bar279: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar279 = try container.decode(String.self, forKey: "bar279")
    }
}

struct Foo280: Decodable {
    let bar280: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar280 = try container.decode(String.self, forKey: "bar280")
    }
}

struct Foo281: Decodable {
    let bar281: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar281 = try container.decode(String.self, forKey: "bar281")
    }
}

struct Foo282: Decodable {
    let bar282: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar282 = try container.decode(String.self, forKey: "bar282")
    }
}

struct Foo283: Decodable {
    let bar283: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar283 = try container.decode(String.self, forKey: "bar283")
    }
}

struct Foo284: Decodable {
    let bar284: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar284 = try container.decode(String.self, forKey: "bar284")
    }
}

struct Foo285: Decodable {
    let bar285: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar285 = try container.decode(String.self, forKey: "bar285")
    }
}

struct Foo286: Decodable {
    let bar286: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar286 = try container.decode(String.self, forKey: "bar286")
    }
}

struct Foo287: Decodable {
    let bar287: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar287 = try container.decode(String.self, forKey: "bar287")
    }
}

struct Foo288: Decodable {
    let bar288: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar288 = try container.decode(String.self, forKey: "bar288")
    }
}

struct Foo289: Decodable {
    let bar289: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar289 = try container.decode(String.self, forKey: "bar289")
    }
}

struct Foo290: Decodable {
    let bar290: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar290 = try container.decode(String.self, forKey: "bar290")
    }
}

struct Foo291: Decodable {
    let bar291: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar291 = try container.decode(String.self, forKey: "bar291")
    }
}

struct Foo292: Decodable {
    let bar292: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar292 = try container.decode(String.self, forKey: "bar292")
    }
}

struct Foo293: Decodable {
    let bar293: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar293 = try container.decode(String.self, forKey: "bar293")
    }
}

struct Foo294: Decodable {
    let bar294: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar294 = try container.decode(String.self, forKey: "bar294")
    }
}

struct Foo295: Decodable {
    let bar295: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar295 = try container.decode(String.self, forKey: "bar295")
    }
}

struct Foo296: Decodable {
    let bar296: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar296 = try container.decode(String.self, forKey: "bar296")
    }
}

struct Foo297: Decodable {
    let bar297: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar297 = try container.decode(String.self, forKey: "bar297")
    }
}

struct Foo298: Decodable {
    let bar298: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar298 = try container.decode(String.self, forKey: "bar298")
    }
}

struct Foo299: Decodable {
    let bar299: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar299 = try container.decode(String.self, forKey: "bar299")
    }
}

struct Foo300: Decodable {
    let bar300: String

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: StringCodingKey.self)
        self.bar300 = try container.decode(String.self, forKey: "bar300")
    }
}

macOS.playground.zip

liamnichols · 2022-07-28T18:19:45Z

Maybe it should state "public API looks like it was written by a hand" and not "the entire code looks like it's written by hand" – that's probably a no-goal.

I think that makes a lot of sense. In fact, the easiest way to use CreateAPI is to generate a Swift Package which often means that you are mostly only dealing with the public interface anyway

AvdLee · 2022-07-29T16:03:04Z

@liamnichols these are incredibly valuable insights! To take the outcomes from this issue into actions;
The only thing I can currently do to reduce binary size would be to set isGeneratingCustomCodingKeys to false, correct?

liamnichols · 2022-07-29T16:35:23Z

The only thing I can currently do to reduce binary size would be to set isGeneratingCustomCodingKeys to false, correct?

So far, that's all I've found yeah. I just applied it to our codebase today as well (down to 11MB from 16.6MB).

I think the remainder is mostly just due to the sheer number of types, and to help with that the only thing that I can think of is to make sure that CreateAPI makes it as easy as possible to omit types that you don't need?

I could imagine that having an option to omit unused entities might be useful? For example, if you use the paths.exclude (or paths.include) options to reduce the number of paths, being able to automatically figure out which entities are now unused and skip their generation might be very handy because it can be tricky to keep track of otherwise.

AvdLee · 2022-07-29T16:49:54Z

I think the remainder is mostly just due to the sheer number of types, and to help with that the only thing that I can think of is to make sure that CreateAPI makes it as easy as possible to omit types that you don't need?

Yes, exactly! That would indeed be useful. My idea was to do this my mapping entities and paths in subdirectories based on the OpenAPI definition. That could be done using the URL paths first query element maybe?

Ideally, I would group my SDK into these subdirectories:

However, I looked at the OpenAPI definition for my SDK and could not really conclude whether this is possible or not.

It would at least be quite a process to group all endpoints into subpackages manually. Having them in subdirectories automatically allows to include certain directories using subpackages in SPM.

Let me know if that makes sense and whether you have alternative ideas!

liamnichols · 2022-07-29T17:06:20Z

Another option could be based on the Tag definitions?

https://swagger.io/docs/specification/grouping-operations-with-tags/

The ASC spec defines the following:

[
  "AgeRatingDeclarations",
  "AppCategories",
  "AppClipAdvancedExperienceImages",
  "AppClipAdvancedExperiences",
  "AppClipAppStoreReviewDetails",
  "AppClipDefaultExperienceLocalizations",
  "AppClipDefaultExperiences",
  "AppClipHeaderImages",
  "AppClips",
  "AppCustomProductPageLocalizations",
  "AppCustomProductPages",
  "AppCustomProductPageVersions",
  "AppEncryptionDeclarations",
  "AppEventLocalizations",
  "AppEvents",
  "AppEventScreenshots",
  "AppEventVideoClips",
  "AppInfoLocalizations",
  "AppInfos",
  "AppPreOrders",
  "AppPreviews",
  "AppPreviewSets",
  "AppPricePoints",
  "AppPrices",
  "AppPriceTiers",
  "Apps",
  "AppScreenshots",
  "AppScreenshotSets",
  "AppStoreReviewAttachments",
  "AppStoreReviewDetails",
  "AppStoreVersionExperiments",
  "AppStoreVersionExperimentTreatmentLocalizations",
  "AppStoreVersionExperimentTreatments",
  "AppStoreVersionLocalizations",
  "AppStoreVersionPhasedReleases",
  "AppStoreVersionPromotions",
  "AppStoreVersionReleaseRequests",
  "AppStoreVersions",
  "AppStoreVersionSubmissions",
  "BetaAppClipInvocationLocalizations",
  "BetaAppClipInvocations",
  "BetaAppLocalizations",
  "BetaAppReviewDetails",
  "BetaAppReviewSubmissions",
  "BetaBuildLocalizations",
  "BetaGroups",
  "BetaLicenseAgreements",
  "BetaTesterInvitations",
  "BetaTesters",
  "BuildBetaDetails",
  "BuildBetaNotifications",
  "BuildBundles",
  "Builds",
  "BundleIdCapabilities",
  "BundleIds",
  "Certificates",
  "CiArtifacts",
  "CiBuildActions",
  "CiBuildRuns",
  "CiIssues",
  "CiMacOsVersions",
  "CiProducts",
  "CiTestResults",
  "CiWorkflows",
  "CiXcodeVersions",
  "CustomerReviewResponses",
  "CustomerReviews",
  "Devices",
  "DiagnosticSignatures",
  "EndUserLicenseAgreements",
  "FinanceReports",
  "GameCenterEnabledVersions",
  "InAppPurchaseAppStoreReviewScreenshots",
  "InAppPurchaseContents",
  "InAppPurchaseLocalizations",
  "InAppPurchasePriceSchedules",
  "InAppPurchases",
  "InAppPurchaseSubmissions",
  "PreReleaseVersions",
  "Profiles",
  "PromotedPurchaseImages",
  "PromotedPurchases",
  "ReviewSubmissionItems",
  "ReviewSubmissions",
  "RoutingAppCoverages",
  "SalesReports",
  "ScmGitReferences",
  "ScmProviders",
  "ScmPullRequests",
  "ScmRepositories",
  "SubscriptionAppStoreReviewScreenshots",
  "SubscriptionGracePeriods",
  "SubscriptionGroupLocalizations",
  "SubscriptionGroups",
  "SubscriptionGroupSubmissions",
  "SubscriptionIntroductoryOffers",
  "SubscriptionLocalizations",
  "SubscriptionOfferCodeCustomCodes",
  "SubscriptionOfferCodeOneTimeUseCodes",
  "SubscriptionOfferCodes",
  "SubscriptionPricePoints",
  "SubscriptionPrices",
  "SubscriptionPromotionalOffers",
  "Subscriptions",
  "SubscriptionSubmissions",
  "Territories",
  "UserInvitations",
  "Users"
]

Maybe that's a bit too granular 😅 But I guess you could define multiple packages, each which define a set of tags?

Something like

paths:
  includeTags:
  - SubscriptionAppStoreReviewScreenshots
  - SubscriptionGracePeriods
  - SubscriptionGroupLocalizations
  - SubscriptionGroups
  - SubscriptionGroupSubmissions
  - SubscriptionIntroductoryOffers
  - SubscriptionLocalizations
  - SubscriptionOfferCodeCustomCodes
  - SubscriptionOfferCodeOneTimeUseCodes
  - SubscriptionOfferCodes
  - SubscriptionPricePoints
  - SubscriptionPrices
  - SubscriptionPromotionalOffers
  - Subscriptions
  - SubscriptionSubmissions

Maybe 🤔

Then theoretically we'd be able to figure out which paths are listed under those tags, and which entities those paths depend on

AvdLee · 2022-07-29T17:17:47Z

Yeah, something like that works! What I want to prevent though is having to run the CreateAPI command for each package. It would be easier to maintain if I can update all entities at once and make the packages link to certain subdirectories that are generated by CreateAPI.

In other words, creating a subdirectory for each tag.

I would then need to manually create subpackages based on these tags. What do you think?

kean · 2022-07-29T17:46:32Z

Most of the generated code is in Entities, so splitting by just Paths wouldn't really solve the issue.

$ cloc Entities

github.com/AlDanial/cloc v 1.92  T=0.18 s (3226.3 files/s, 353885.5 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Swift                          571          10334           2403          49894
-------------------------------------------------------------------------------

$ cloc Paths

github.com/AlDanial/cloc v 1.92  T=0.15 s (3837.4 files/s, 205311.7 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Swift                          581           3887           2904          24294
-------------------------------------------------------------------------------

kean · 2022-07-29T17:59:41Z

By the way, anyone with CreateAPI could simply generate their own API definition. 😉 It would be fantastic if you could choose what APIs to generate maybe by tags and/or paths (regex?). Another option could be skipping deprecated APIs.

liamnichols · 2022-07-30T13:30:00Z

Most of the generated code is in Entities, so splitting by just Paths wouldn't really solve the issue.

Yeah so my thinking here was to combine it with some other new preference, something on the line of isSkippingUnusedEntities. That way, if the filtered list of paths only depended on EntityX and EntityY, we'd skip generating EntityZ.

This would also be useful on the existing paths-based include option too.

Including by tags would just make it a little more convenient instead of having to list everything out.

Another option could be skipping deprecated APIs.

That sounds like another great option to add too! (isSkippingDeprecatedPaths or something)

What I want to prevent though is having to run the CreateAPI command for each package. It would be easier to maintain if I can update all entities at once and make the packages link to certain subdirectories that are generated by CreateAPI.

Hmm yeah that makes sense, although it might require a significant bit of work to the generate command since it's currently structured around generating a single module/package. I'm not sure how much of a priority this kind of change would be in relation to everything else. Happy to try and help out if you want to dig a bit deeper?

Thinking about it some more, this is probably a great use of the new Swift Package Plugins.. You could probably define something like this:

import Foundation
import PackagePlugin

@main 
struct UpdateOpenAPI: CommandPlugin {
    func performCommand(context: PluginContext, arguments: [String]) throws {
        let targets = [
            "Subscriptions": [
                "TagA",
                "TagB",
                "TagC",
            ],
            "Betas": [
                "TagD",
                "TagE",
            ]
        ]

        for (target, tags) in targets {
            // 1. Write out a create-api.yaml configuration including `tags`
            // 2. Invoke the `create-api` cli with the correct `--module` and output path
        }
    }
}

Updating everything in your repo would then just be an invocation something like this:

$ swift package --allow-writing-to-directory ./ update-open-api

AvdLee · 2022-08-03T15:03:50Z

Most of the generated code is in Entities, so splitting by just Paths wouldn't really solve the issue.

Correct, but the paths come with related entities, so splitting paths would equally be splitting entities.

Hmm yeah that makes sense, although it might require a significant bit of work to the generate command since it's currently structured around generating a single module/package. I'm not sure how much of a priority this kind of change would be in relation to everything else. Happy to try and help out if you want to dig a bit deeper?

Yeah, I see! It's not a super big priority right now. I could always make that mapping myself in the SDK!

Thinking about it some more, this is probably a great use of the new Swift Package Plugins.. You could probably define something like this:

I can see that working for sure!

AvdLee mentioned this issue Jul 28, 2022

Create subpackages to only include endpoints that are used AvdLee/appstoreconnect-swift-sdk#183

Open

liamnichols mentioned this issue Jul 28, 2022

Conforming to Codable adds an unexpected increase to the binary size apple/swift#60287

Open

AvdLee mentioned this issue Jul 29, 2022

Reduce binary size by using a different codable technique AvdLee/appstoreconnect-swift-sdk#189

Merged

This was referenced Aug 1, 2022

Use Swift Package Plugin for generating OpenAPI code AvdLee/appstoreconnect-swift-sdk#191

Merged

Make --split (-s) the default behaviour #74

Closed

Enable isGeneratingCustomCodingKeys by default #75

Closed

This was referenced Aug 4, 2022

Replace entities option isGeneratingCustomCodingKeys with isUsingStringsForCodingKeys #86

Closed

[BREAKING] Require --split or --no-split flag #87

Closed

Enable optimizeCodingKeys by default #115

Merged

LePips mentioned this issue Aug 7, 2022

Paths tags organization #121

Open

mxsc mentioned this issue Apr 16, 2024

Use custom coding key and implement codable functions on our own to reduce binary size lunarway/SwaggerSwift#144

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Compile time evaluation #57

Compile time evaluation #57

AvdLee commented Jul 23, 2022

kean commented Jul 23, 2022 •

edited

liamnichols commented Jul 25, 2022

AvdLee commented Jul 26, 2022

liamnichols commented Jul 26, 2022

AvdLee commented Jul 28, 2022

kean commented Jul 28, 2022

liamnichols commented Jul 28, 2022

liamnichols commented Jul 28, 2022

AvdLee commented Jul 29, 2022

liamnichols commented Jul 29, 2022

AvdLee commented Jul 29, 2022

liamnichols commented Jul 29, 2022

AvdLee commented Jul 29, 2022

kean commented Jul 29, 2022 •

edited

kean commented Jul 29, 2022 •

edited

liamnichols commented Jul 30, 2022

AvdLee commented Aug 3, 2022

Compile time evaluation #57

Compile time evaluation #57

Comments

AvdLee commented Jul 23, 2022

kean commented Jul 23, 2022 • edited

liamnichols commented Jul 25, 2022

AvdLee commented Jul 26, 2022

liamnichols commented Jul 26, 2022

AvdLee commented Jul 28, 2022

kean commented Jul 28, 2022

liamnichols commented Jul 28, 2022

liamnichols commented Jul 28, 2022

AvdLee commented Jul 29, 2022

liamnichols commented Jul 29, 2022

AvdLee commented Jul 29, 2022

liamnichols commented Jul 29, 2022

AvdLee commented Jul 29, 2022

kean commented Jul 29, 2022 • edited

kean commented Jul 29, 2022 • edited

liamnichols commented Jul 30, 2022

AvdLee commented Aug 3, 2022

kean commented Jul 23, 2022 •

edited

kean commented Jul 29, 2022 •

edited

kean commented Jul 29, 2022 •

edited