DeserializeCB.expressions

.Lambda #Lambda1<System.Func`2[Bond.Protocols.CompactBinaryReader`1[Bond.IO.Unsafe.InputStream],System.Object]>(Bond.Protocols.CompactBinaryReader`1[Bond.IO.Unsafe.InputStream] $reader)
{
    .Block(ExpressionsTest.Example $Example_result) {
        .Block() {
            $Example_result = .New ExpressionsTest.Example();
            .Block(System.Int32 $depth) {
                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                .Try {
                    .Block() {
                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                        .Block(
                            Bond.BondDataType $fieldType,
                            System.UInt16 $fieldId) {
                            .Call $reader.ReadStructBegin();
                            .Default(System.Void);
                            .Block() {
                                .Block(System.Int32 $depth) {
                                    $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                    .Try {
                                        .Block() {
                                            .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                            .Block(
                                                Bond.BondDataType $fieldType,
                                                System.UInt16 $fieldId) {
                                                .Call $reader.ReadBaseBegin();
                                                .Default(System.Void);
                                                .Default(System.Void);
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Loop  {
                                                    .If ((System.Int32)$fieldType > 1) {
                                                        .Block() {
                                                            .If ($fieldId == .Constant<System.UInt16>(0)) {
                                                                .Block() {
                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(System.Int32 $depth) {
                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                            .Try {
                                                                                .Block() {
                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                    .Block(
                                                                                        System.Int32 $count,
                                                                                        Bond.BondDataType $elementType) {
                                                                                        .Call $reader.ReadContainerBegin(
                                                                                            $count,
                                                                                            $elementType);
                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                            .Block(System.Collections.Generic.List`1[System.UInt64] $Convert(Example_result).vvb_item) {
                                                                                                .Block(System.Int32 $Convert(Example_result).vvb_count) {
                                                                                                    $Convert(Example_result).vvb_count = $count;
                                                                                                    .If ($Convert(Example_result).vvb_count > 65536) {
                                                                                                        $Convert(Example_result).vvb_count = 65536
                                                                                                    } .Else {
                                                                                                        .Default(System.Void)
                                                                                                    };
                                                                                                    (((ExpressionsTest.Base)$Example_result).vvb).Capacity = $Convert(Example_result).vvb_count
                                                                                                };
                                                                                                .Loop  {
                                                                                                    .If ($count-- > 0) {
                                                                                                        .Block() {
                                                                                                            .Block(System.Int32 $depth) {
                                                                                                                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                                .Try {
                                                                                                                    .Block() {
                                                                                                                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                                        .Block(
                                                                                                                            System.Int32 $count,
                                                                                                                            Bond.BondDataType $elementType) {
                                                                                                                            .Call $reader.ReadContainerBegin(
                                                                                                                                $count,
                                                                                                                                $elementType);
                                                                                                                            .If ($elementType == .Constant<Bond.BondDataType>(BT_UINT64)) {
                                                                                                                                .Block(System.UInt64 $Convert(Example_result).vvb_item_item) {
                                                                                                                                    .Block(System.Int32 $Convert(Example_result).vvb_item_count) {
                                                                                                                                        $Convert(Example_result).vvb_item_count = $count;
                                                                                                                                        .If ($Convert(Example_result).vvb_item_count > 65536) {
                                                                                                                                            $Convert(Example_result).vvb_item_count = 65536
                                                                                                                                        } .Else {
                                                                                                                                            .Default(System.Void)
                                                                                                                                        };
                                                                                                                                        $Convert(Example_result).vvb_item = .New System.Collections.Generic.List`1[System.UInt64]($Convert(Example_result).vvb_item_count)
                                                                                                                                    };
                                                                                                                                    .Loop  {
                                                                                                                                        .If ($count-- > 0) {
                                                                                                                                            .Block() {
                                                                                                                                                $Convert(Example_result).vvb_item_item = .Call $reader.ReadUInt64();
                                                                                                                                                .Call $Convert(Example_result).vvb_item.Add($Convert(Example_result).vvb_item_item)
                                                                                                                                            }
                                                                                                                                        } .Else {
                                                                                                                                            .Break end { }
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                    .LabelTarget end:;
                                                                                                                                    .Default(System.Void)
                                                                                                                                }
                                                                                                                            } .Else {
                                                                                                                                .If ($elementType == .Constant<Bond.BondDataType>(BT_UINT32)) {
                                                                                                                                    .Block(System.UInt64 $Convert(Example_result).vvb_item_item) {
                                                                                                                                        .Block(System.Int32 $Convert(Example_result).vvb_item_count) {
                                                                                                                                            $Convert(Example_result).vvb_item_count = $count;
                                                                                                                                            .If ($Convert(Example_result).vvb_item_count > 65536) {
                                                                                                                                                $Convert(Example_result).vvb_item_count = 65536
                                                                                                                                            } .Else {
                                                                                                                                                .Default(System.Void)
                                                                                                                                            };
                                                                                                                                            $Convert(Example_result).vvb_item = .New System.Collections.Generic.List`1[System.UInt64]($Convert(Example_result).vvb_item_count)
                                                                                                                                        };
                                                                                                                                        .Loop  {
                                                                                                                                            .If ($count-- > 0) {
                                                                                                                                                .Block() {
                                                                                                                                                    $Convert(Example_result).vvb_item_item = (System.UInt64).Call $reader.ReadUInt32();
                                                                                                                                                    .Call $Convert(Example_result).vvb_item.Add($Convert(Example_result).vvb_item_item)
                                                                                                                                                }
                                                                                                                                            } .Else {
                                                                                                                                                .Break end { }
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                        .LabelTarget end:;
                                                                                                                                        .Default(System.Void)
                                                                                                                                    }
                                                                                                                                } .Else {
                                                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                                                                                                        .Block(System.UInt64 $Convert(Example_result).vvb_item_item) {
                                                                                                                                            .Block(System.Int32 $Convert(Example_result).vvb_item_count) {
                                                                                                                                                $Convert(Example_result).vvb_item_count = $count;
                                                                                                                                                .If ($Convert(Example_result).vvb_item_count > 65536) {
                                                                                                                                                    $Convert(Example_result).vvb_item_count = 65536
                                                                                                                                                } .Else {
                                                                                                                                                    .Default(System.Void)
                                                                                                                                                };
                                                                                                                                                $Convert(Example_result).vvb_item = .New System.Collections.Generic.List`1[System.UInt64]($Convert(Example_result).vvb_item_count)
                                                                                                                                            };
                                                                                                                                            .Loop  {
                                                                                                                                                .If ($count-- > 0) {
                                                                                                                                                    .Block() {
                                                                                                                                                        $Convert(Example_result).vvb_item_item = (System.UInt64).Call $reader.ReadUInt16();
                                                                                                                                                        .Call $Convert(Example_result).vvb_item.Add($Convert(Example_result).vvb_item_item)
                                                                                                                                                    }
                                                                                                                                                } .Else {
                                                                                                                                                    .Break end { }
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                            .LabelTarget end:;
                                                                                                                                            .Default(System.Void)
                                                                                                                                        }
                                                                                                                                    } .Else {
                                                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                                                                                                            .Block(System.UInt64 $Convert(Example_result).vvb_item_item) {
                                                                                                                                                .Block(System.Int32 $Convert(Example_result).vvb_item_count) {
                                                                                                                                                    $Convert(Example_result).vvb_item_count = $count;
                                                                                                                                                    .If ($Convert(Example_result).vvb_item_count > 65536) {
                                                                                                                                                        $Convert(Example_result).vvb_item_count = 65536
                                                                                                                                                    } .Else {
                                                                                                                                                        .Default(System.Void)
                                                                                                                                                    };
                                                                                                                                                    $Convert(Example_result).vvb_item = .New System.Collections.Generic.List`1[System.UInt64]($Convert(Example_result).vvb_item_count)
                                                                                                                                                };
                                                                                                                                                .Loop  {
                                                                                                                                                    .If ($count-- > 0) {
                                                                                                                                                        .Block() {
                                                                                                                                                            $Convert(Example_result).vvb_item_item = (System.UInt64).Call $reader.ReadUInt8();
                                                                                                                                                            .Call $Convert(Example_result).vvb_item.Add($Convert(Example_result).vvb_item_item)
                                                                                                                                                        }
                                                                                                                                                    } .Else {
                                                                                                                                                        .Break end { }
                                                                                                                                                    }
                                                                                                                                                }
                                                                                                                                                .LabelTarget end:;
                                                                                                                                                .Default(System.Void)
                                                                                                                                            }
                                                                                                                                        } .Else {
                                                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                                                .Constant<Bond.BondDataType>(BT_UINT64),
                                                                                                                                                $elementType)
                                                                                                                                        }
                                                                                                                                    }
                                                                                                                                }
                                                                                                                            };
                                                                                                                            .Call $reader.ReadContainerEnd()
                                                                                                                        }
                                                                                                                    }
                                                                                                                } .Finally {
                                                                                                                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                                }
                                                                                                            };
                                                                                                            .Call (((ExpressionsTest.Base)$Example_result).vvb).Add($Convert(Example_result).vvb_item)
                                                                                                        }
                                                                                                    } .Else {
                                                                                                        .Break end { }
                                                                                                    }
                                                                                                }
                                                                                                .LabelTarget end:;
                                                                                                .Default(System.Void)
                                                                                            }
                                                                                        } .Else {
                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                .Constant<Bond.BondDataType>(BT_LIST),
                                                                                                $elementType)
                                                                                        };
                                                                                        .Call $reader.ReadContainerEnd()
                                                                                    }
                                                                                }
                                                                            } .Finally {
                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                            }
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $fieldType)
                                                                    };
                                                                    .Call $reader.ReadFieldEnd();
                                                                    .Call $reader.ReadFieldBegin(
                                                                        $fieldType,
                                                                        $fieldId);
                                                                    .Break end { }
                                                                }
                                                            } .Else {
                                                                .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                    .Block() {
                                                                        .Default(System.Void);
                                                                        .Break end { }
                                                                    }
                                                                } .Else {
                                                                    .Call $reader.Skip($fieldType)
                                                                }
                                                            };
                                                            .Call $reader.ReadFieldEnd();
                                                            .Call $reader.ReadFieldBegin(
                                                                $fieldType,
                                                                $fieldId);
                                                            .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                .Break end { }
                                                            } .Else {
                                                                .Default(System.Void)
                                                            }
                                                        }
                                                    } .Else {
                                                        .Block() {
                                                            .Default(System.Void);
                                                            .Break end { }
                                                        }
                                                    }
                                                }
                                                .LabelTarget end:;
                                                .Loop  {
                                                    .If ((System.Int32)$fieldType > 1) {
                                                        .Block() {
                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                                                .Default(System.Void)
                                                            } .Else {
                                                                .Block() {
                                                                    .Call $reader.Skip($fieldType);
                                                                    .Call $reader.ReadFieldEnd()
                                                                }
                                                            };
                                                            .Call $reader.ReadFieldBegin(
                                                                $fieldType,
                                                                $fieldId)
                                                        }
                                                    } .Else {
                                                        .Break end { }
                                                    }
                                                }
                                                .LabelTarget end:;
                                                .Call $reader.ReadBaseEnd();
                                                .Default(System.Void)
                                            }
                                        }
                                    } .Finally {
                                        .Call Bond.MaxDepthChecker.SetDepth($depth)
                                    }
                                }
                            };
                            .Call $reader.ReadFieldBegin(
                                $fieldType,
                                $fieldId);
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(0)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_BOOL)) {
                                                    $Example_result._bool = .Call $reader.ReadBool()
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_BOOL),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(0)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(2)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_STRING)) {
                                                    $Example_result._str = .Call $reader.ReadString()
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_STRING),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(2)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(2)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(12)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT32)) {
                                                    $Example_result._uint32 = .Call $reader.ReadUInt32()
                                                } .Else {
                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                        $Example_result._uint32 = (System.UInt32).Call $reader.ReadUInt16()
                                                    } .Else {
                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                            $Example_result._uint32 = (System.UInt32).Call $reader.ReadUInt8()
                                                        } .Else {
                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                .Constant<Bond.BondDataType>(BT_UINT32),
                                                                $fieldType)
                                                        }
                                                    }
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(12)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(12)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(14)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                    $Example_result._int8 = .Call $reader.ReadInt8()
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_INT8),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(14)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(14)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(17)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT64)) {
                                                    $Example_result._int64 = .Call $reader.ReadInt64()
                                                } .Else {
                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                        $Example_result._int64 = (System.Int64).Call $reader.ReadInt32()
                                                    } .Else {
                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                            $Example_result._int64 = (System.Int64).Call $reader.ReadInt16()
                                                        } .Else {
                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                $Example_result._int64 = (System.Int64).Call $reader.ReadInt8()
                                                            } .Else {
                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                    .Constant<Bond.BondDataType>(BT_INT64),
                                                                    $fieldType)
                                                            }
                                                        }
                                                    }
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(17)) {
                                                .Block() {
                                                    .Invoke (.Lambda #Lambda3<System.Action`2[System.String,System.String]>)(
                                                        "Example",
                                                        "_int64");
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(17)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Invoke (.Lambda #Lambda3<System.Action`2[System.String,System.String]>)(
                                            "Example",
                                            "_int64");
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(18)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_DOUBLE)) {
                                                    $Example_result._double = .Call $reader.ReadDouble()
                                                } .Else {
                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_FLOAT)) {
                                                        $Example_result._double = (System.Double).Call $reader.ReadFloat()
                                                    } .Else {
                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                            .Constant<Bond.BondDataType>(BT_DOUBLE),
                                                            $fieldType)
                                                    }
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(18)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(18)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(20)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_STRUCT)) {
                                                    .Block() {
                                                        .Block(System.Int32 $depth) {
                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                            .Try {
                                                                .Block() {
                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                    .Block(
                                                                        Bond.BondDataType $fieldType,
                                                                        System.UInt16 $fieldId) {
                                                                        .Call $reader.ReadStructBegin();
                                                                        .Default(System.Void);
                                                                        .Default(System.Void);
                                                                        .Call $reader.ReadFieldBegin(
                                                                            $fieldType,
                                                                            $fieldId);
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(0)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT32)) {
                                                                                                ($Example_result.guid).Data1 = .Call $reader.ReadUInt32()
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                                                                    ($Example_result.guid).Data1 = (System.UInt32).Call $reader.ReadUInt16()
                                                                                                } .Else {
                                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                                                                        ($Example_result.guid).Data1 = (System.UInt32).Call $reader.ReadUInt8()
                                                                                                    } .Else {
                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                            .Constant<Bond.BondDataType>(BT_UINT32),
                                                                                                            $fieldType)
                                                                                                    }
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(1)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                                                                ($Example_result.guid).Data2 = .Call $reader.ReadUInt16()
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                                                                    ($Example_result.guid).Data2 = (System.UInt16).Call $reader.ReadUInt8()
                                                                                                } .Else {
                                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                        .Constant<Bond.BondDataType>(BT_UINT16),
                                                                                                        $fieldType)
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(1)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(1)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(2)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                                                                ($Example_result.guid).Data3 = .Call $reader.ReadUInt16()
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                                                                    ($Example_result.guid).Data3 = (System.UInt16).Call $reader.ReadUInt8()
                                                                                                } .Else {
                                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                        .Constant<Bond.BondDataType>(BT_UINT16),
                                                                                                        $fieldType)
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(2)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(2)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(3)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT64)) {
                                                                                                ($Example_result.guid).Data4 = .Call $reader.ReadUInt64()
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT32)) {
                                                                                                    ($Example_result.guid).Data4 = (System.UInt64).Call $reader.ReadUInt32()
                                                                                                } .Else {
                                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT16)) {
                                                                                                        ($Example_result.guid).Data4 = (System.UInt64).Call $reader.ReadUInt16()
                                                                                                    } .Else {
                                                                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_UINT8)) {
                                                                                                            ($Example_result.guid).Data4 = (System.UInt64).Call $reader.ReadUInt8()
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_UINT64),
                                                                                                                $fieldType)
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(3)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(3)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ($fieldType != .Constant<Bond.BondDataType>(BT_STOP)) {
                                                                                .Block() {
                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                                                                        .Default(System.Void)
                                                                                    } .Else {
                                                                                        .Block() {
                                                                                            .Call $reader.Skip($fieldType);
                                                                                            .Call $reader.ReadFieldEnd()
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId)
                                                                                }
                                                                            } .Else {
                                                                                .Break end { }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Call $reader.ReadStructEnd();
                                                                        .Default(System.Void)
                                                                    }
                                                                }
                                                            } .Finally {
                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                            }
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_STRUCT),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(20)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(20)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(30)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                        .Block(System.Int32 $Example_result._int32Vector_item) {
                                                                            .Block(System.Int32 $Example_result._int32Vector_count) {
                                                                                $Example_result._int32Vector_count = $count;
                                                                                .If ($Example_result._int32Vector_count > 65536) {
                                                                                    $Example_result._int32Vector_count = 65536
                                                                                } .Else {
                                                                                    .Default(System.Void)
                                                                                };
                                                                                ($Example_result._int32Vector).Capacity = $Example_result._int32Vector_count
                                                                            };
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        $Example_result._int32Vector_item = .Call $reader.ReadInt32();
                                                                                        .Call ($Example_result._int32Vector).Add($Example_result._int32Vector_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                            .Block(System.Int32 $Example_result._int32Vector_item) {
                                                                                .Block(System.Int32 $Example_result._int32Vector_count) {
                                                                                    $Example_result._int32Vector_count = $count;
                                                                                    .If ($Example_result._int32Vector_count > 65536) {
                                                                                        $Example_result._int32Vector_count = 65536
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    };
                                                                                    ($Example_result._int32Vector).Capacity = $Example_result._int32Vector_count
                                                                                };
                                                                                .Loop  {
                                                                                    .If ($count-- > 0) {
                                                                                        .Block() {
                                                                                            $Example_result._int32Vector_item = (System.Int32).Call $reader.ReadInt16();
                                                                                            .Call ($Example_result._int32Vector).Add($Example_result._int32Vector_item)
                                                                                        }
                                                                                    } .Else {
                                                                                        .Break end { }
                                                                                    }
                                                                                }
                                                                                .LabelTarget end:;
                                                                                .Default(System.Void)
                                                                            }
                                                                        } .Else {
                                                                            .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                .Block(System.Int32 $Example_result._int32Vector_item) {
                                                                                    .Block(System.Int32 $Example_result._int32Vector_count) {
                                                                                        $Example_result._int32Vector_count = $count;
                                                                                        .If ($Example_result._int32Vector_count > 65536) {
                                                                                            $Example_result._int32Vector_count = 65536
                                                                                        } .Else {
                                                                                            .Default(System.Void)
                                                                                        };
                                                                                        ($Example_result._int32Vector).Capacity = $Example_result._int32Vector_count
                                                                                    };
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._int32Vector_item = (System.Int32).Call $reader.ReadInt8();
                                                                                                .Call ($Example_result._int32Vector).Add($Example_result._int32Vector_item)
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:;
                                                                                    .Default(System.Void)
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_INT32),
                                                                                    $elementType)
                                                                            }
                                                                        }
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(30)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(30)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(40)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_STRUCT)) {
                                                                        .Block(ExpressionsTest.Nested $Example_result._nestedVector_item) {
                                                                            .Default(System.Void);
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block() {
                                                                                            $Example_result._nestedVector_item = .New ExpressionsTest.Nested();
                                                                                            .Block(System.Int32 $depth) {
                                                                                                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                .Try {
                                                                                                    .Block() {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                        .Block(
                                                                                                            Bond.BondDataType $fieldType,
                                                                                                            System.UInt16 $fieldId) {
                                                                                                            .Call $reader.ReadStructBegin();
                                                                                                            .Default(System.Void);
                                                                                                            .Default(System.Void);
                                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                                $fieldType,
                                                                                                                $fieldId);
                                                                                                            .Loop  {
                                                                                                                .If ((System.Int32)$fieldType > 1) {
                                                                                                                    .Block() {
                                                                                                                        .If ($fieldId == .Constant<System.UInt16>(0)) {
                                                                                                                            .Block() {
                                                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_DOUBLE)) {
                                                                                                                                    $Example_result._nestedVector_item._double = .Call $reader.ReadDouble()
                                                                                                                                } .Else {
                                                                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_FLOAT)) {
                                                                                                                                        $Example_result._nestedVector_item._double = (System.Double).Call $reader.ReadFloat()
                                                                                                                                    } .Else {
                                                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                                            .Constant<Bond.BondDataType>(BT_DOUBLE),
                                                                                                                                            $fieldType)
                                                                                                                                    }
                                                                                                                                };
                                                                                                                                .Call $reader.ReadFieldEnd();
                                                                                                                                .Call $reader.ReadFieldBegin(
                                                                                                                                    $fieldType,
                                                                                                                                    $fieldId);
                                                                                                                                .Break end { }
                                                                                                                            }
                                                                                                                        } .Else {
                                                                                                                            .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                                                                .Block() {
                                                                                                                                    .Default(System.Void);
                                                                                                                                    .Break end { }
                                                                                                                                }
                                                                                                                            } .Else {
                                                                                                                                .Call $reader.Skip($fieldType)
                                                                                                                            }
                                                                                                                        };
                                                                                                                        .Call $reader.ReadFieldEnd();
                                                                                                                        .Call $reader.ReadFieldBegin(
                                                                                                                            $fieldType,
                                                                                                                            $fieldId);
                                                                                                                        .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                                                            .Break end { }
                                                                                                                        } .Else {
                                                                                                                            .Default(System.Void)
                                                                                                                        }
                                                                                                                    }
                                                                                                                } .Else {
                                                                                                                    .Block() {
                                                                                                                        .Default(System.Void);
                                                                                                                        .Break end { }
                                                                                                                    }
                                                                                                                }
                                                                                                            }
                                                                                                            .LabelTarget end:;
                                                                                                            .Loop  {
                                                                                                                .If ($fieldType != .Constant<Bond.BondDataType>(BT_STOP)) {
                                                                                                                    .Block() {
                                                                                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                                                                                                            .Default(System.Void)
                                                                                                                        } .Else {
                                                                                                                            .Block() {
                                                                                                                                .Call $reader.Skip($fieldType);
                                                                                                                                .Call $reader.ReadFieldEnd()
                                                                                                                            }
                                                                                                                        };
                                                                                                                        .Call $reader.ReadFieldBegin(
                                                                                                                            $fieldType,
                                                                                                                            $fieldId)
                                                                                                                    }
                                                                                                                } .Else {
                                                                                                                    .Break end { }
                                                                                                                }
                                                                                                            }
                                                                                                            .LabelTarget end:;
                                                                                                            .Call $reader.ReadStructEnd();
                                                                                                            .Default(System.Void)
                                                                                                        }
                                                                                                    }
                                                                                                } .Finally {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                }
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._nestedVector).Add($Example_result._nestedVector_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_STRUCT),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(40)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(40)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(50)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                        $Example_result.b = .Call $reader.ReadBytes($count)
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(50)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(50)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(51)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(System.ArraySegment`1[System.Byte] $Example_result._blobList_item) {
                                                                            .Default(System.Void);
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._blobList_item = .Call $reader.ReadBytes($count)
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._blobList).Add($Example_result._blobList_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(51)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(51)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(52)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(System.ArraySegment`1[System.Byte] $Example_result._blobVector_item) {
                                                                            .Block(System.Int32 $Example_result._blobVector_count) {
                                                                                $Example_result._blobVector_count = $count;
                                                                                .If ($Example_result._blobVector_count > 65536) {
                                                                                    $Example_result._blobVector_count = 65536
                                                                                } .Else {
                                                                                    .Default(System.Void)
                                                                                };
                                                                                ($Example_result._blobVector).Capacity = $Example_result._blobVector_count
                                                                            };
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._blobVector_item = .Call $reader.ReadBytes($count)
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._blobVector).Add($Example_result._blobVector_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(52)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(52)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(53)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_MAP)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $keyType,
                                                                    Bond.BondDataType $valueType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $keyType,
                                                                        $valueType);
                                                                    .If ($keyType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                        .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                            .Block(
                                                                                System.Int32 $Example_result._blobMap_key,
                                                                                System.ArraySegment`1[System.Byte] $Example_result._blobMap_value) {
                                                                                .Default(System.Void);
                                                                                .Loop  {
                                                                                    .If ($count-- > 0) {
                                                                                        .Block() {
                                                                                            $Example_result._blobMap_key = .Call $reader.ReadInt32();
                                                                                            .Default(System.Void);
                                                                                            .Block(System.Int32 $depth) {
                                                                                                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                .Try {
                                                                                                    .Block() {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                        .Block(
                                                                                                            System.Int32 $count,
                                                                                                            Bond.BondDataType $elementType) {
                                                                                                            .Call $reader.ReadContainerBegin(
                                                                                                                $count,
                                                                                                                $elementType);
                                                                                                            .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                $Example_result._blobMap_value = .Call $reader.ReadBytes($count)
                                                                                                            } .Else {
                                                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                    .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                    $elementType)
                                                                                                            };
                                                                                                            .Call $reader.ReadContainerEnd()
                                                                                                        }
                                                                                                    }
                                                                                                } .Finally {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                }
                                                                                            };
                                                                                            ($Example_result._blobMap).Item[$Example_result._blobMap_key] = $Example_result._blobMap_value
                                                                                        }
                                                                                    } .Else {
                                                                                        .Break end { }
                                                                                    }
                                                                                }
                                                                                .LabelTarget end:
                                                                            }
                                                                        } .Else {
                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                .Constant<Bond.BondDataType>(BT_LIST),
                                                                                $valueType)
                                                                        }
                                                                    } .Else {
                                                                        .If ($keyType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                            .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                .Block(
                                                                                    System.Int32 $Example_result._blobMap_key,
                                                                                    System.ArraySegment`1[System.Byte] $Example_result._blobMap_value) {
                                                                                    .Default(System.Void);
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._blobMap_key = (System.Int32).Call $reader.ReadInt16();
                                                                                                .Default(System.Void);
                                                                                                .Block(System.Int32 $depth) {
                                                                                                    $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                    .Try {
                                                                                                        .Block() {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                            .Block(
                                                                                                                System.Int32 $count,
                                                                                                                Bond.BondDataType $elementType) {
                                                                                                                .Call $reader.ReadContainerBegin(
                                                                                                                    $count,
                                                                                                                    $elementType);
                                                                                                                .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                    $Example_result._blobMap_value = .Call $reader.ReadBytes($count)
                                                                                                                } .Else {
                                                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                        .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                        $elementType)
                                                                                                                };
                                                                                                                .Call $reader.ReadContainerEnd()
                                                                                                            }
                                                                                                        }
                                                                                                    } .Finally {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                    }
                                                                                                };
                                                                                                ($Example_result._blobMap).Item[$Example_result._blobMap_key] = $Example_result._blobMap_value
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_LIST),
                                                                                    $valueType)
                                                                            }
                                                                        } .Else {
                                                                            .If ($keyType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                    .Block(
                                                                                        System.Int32 $Example_result._blobMap_key,
                                                                                        System.ArraySegment`1[System.Byte] $Example_result._blobMap_value) {
                                                                                        .Default(System.Void);
                                                                                        .Loop  {
                                                                                            .If ($count-- > 0) {
                                                                                                .Block() {
                                                                                                    $Example_result._blobMap_key = (System.Int32).Call $reader.ReadInt8();
                                                                                                    .Default(System.Void);
                                                                                                    .Block(System.Int32 $depth) {
                                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                        .Try {
                                                                                                            .Block() {
                                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                                .Block(
                                                                                                                    System.Int32 $count,
                                                                                                                    Bond.BondDataType $elementType) {
                                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                                        $count,
                                                                                                                        $elementType);
                                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                        $Example_result._blobMap_value = .Call $reader.ReadBytes($count)
                                                                                                                    } .Else {
                                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                            $elementType)
                                                                                                                    };
                                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                                }
                                                                                                            }
                                                                                                        } .Finally {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                        }
                                                                                                    };
                                                                                                    ($Example_result._blobMap).Item[$Example_result._blobMap_key] = $Example_result._blobMap_value
                                                                                                }
                                                                                            } .Else {
                                                                                                .Break end { }
                                                                                            }
                                                                                        }
                                                                                        .LabelTarget end:
                                                                                    }
                                                                                } .Else {
                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                                                        $valueType)
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_INT32),
                                                                                    $keyType)
                                                                            }
                                                                        }
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_MAP),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(53)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(53)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(54)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block() {
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block(System.Int32 $depth) {
                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                        .Try {
                                                                                            .Block() {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                .Block(
                                                                                                    System.Int32 $count,
                                                                                                    Bond.BondDataType $elementType) {
                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                        $count,
                                                                                                        $elementType);
                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                        $Example_result._blobNullable = .Call $reader.ReadBytes($count)
                                                                                                    } .Else {
                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                            $elementType)
                                                                                                    };
                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                }
                                                                                            }
                                                                                        } .Finally {
                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                        }
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(54)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(54)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(60)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_MAP)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $keyType,
                                                                    Bond.BondDataType $valueType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $keyType,
                                                                        $valueType);
                                                                    .If ($keyType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                        .If ($valueType == .Constant<Bond.BondDataType>(BT_DOUBLE)) {
                                                                            .Block(
                                                                                System.Int32 $Example_result._map_key,
                                                                                System.Double $Example_result._map_value) {
                                                                                .Default(System.Void);
                                                                                .Loop  {
                                                                                    .If ($count-- > 0) {
                                                                                        .Block() {
                                                                                            $Example_result._map_key = .Call $reader.ReadInt32();
                                                                                            .Default(System.Void);
                                                                                            $Example_result._map_value = .Call $reader.ReadDouble();
                                                                                            ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                        }
                                                                                    } .Else {
                                                                                        .Break end { }
                                                                                    }
                                                                                }
                                                                                .LabelTarget end:
                                                                            }
                                                                        } .Else {
                                                                            .If ($valueType == .Constant<Bond.BondDataType>(BT_FLOAT)) {
                                                                                .Block(
                                                                                    System.Int32 $Example_result._map_key,
                                                                                    System.Double $Example_result._map_value) {
                                                                                    .Default(System.Void);
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._map_key = .Call $reader.ReadInt32();
                                                                                                .Default(System.Void);
                                                                                                $Example_result._map_value = (System.Double).Call $reader.ReadFloat();
                                                                                                ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_DOUBLE),
                                                                                    $valueType)
                                                                            }
                                                                        }
                                                                    } .Else {
                                                                        .If ($keyType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                            .If ($valueType == .Constant<Bond.BondDataType>(BT_DOUBLE)) {
                                                                                .Block(
                                                                                    System.Int32 $Example_result._map_key,
                                                                                    System.Double $Example_result._map_value) {
                                                                                    .Default(System.Void);
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._map_key = (System.Int32).Call $reader.ReadInt16();
                                                                                                .Default(System.Void);
                                                                                                $Example_result._map_value = .Call $reader.ReadDouble();
                                                                                                ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:
                                                                                }
                                                                            } .Else {
                                                                                .If ($valueType == .Constant<Bond.BondDataType>(BT_FLOAT)) {
                                                                                    .Block(
                                                                                        System.Int32 $Example_result._map_key,
                                                                                        System.Double $Example_result._map_value) {
                                                                                        .Default(System.Void);
                                                                                        .Loop  {
                                                                                            .If ($count-- > 0) {
                                                                                                .Block() {
                                                                                                    $Example_result._map_key = (System.Int32).Call $reader.ReadInt16();
                                                                                                    .Default(System.Void);
                                                                                                    $Example_result._map_value = (System.Double).Call $reader.ReadFloat();
                                                                                                    ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                                }
                                                                                            } .Else {
                                                                                                .Break end { }
                                                                                            }
                                                                                        }
                                                                                        .LabelTarget end:
                                                                                    }
                                                                                } .Else {
                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                        .Constant<Bond.BondDataType>(BT_DOUBLE),
                                                                                        $valueType)
                                                                                }
                                                                            }
                                                                        } .Else {
                                                                            .If ($keyType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                .If ($valueType == .Constant<Bond.BondDataType>(BT_DOUBLE)) {
                                                                                    .Block(
                                                                                        System.Int32 $Example_result._map_key,
                                                                                        System.Double $Example_result._map_value) {
                                                                                        .Default(System.Void);
                                                                                        .Loop  {
                                                                                            .If ($count-- > 0) {
                                                                                                .Block() {
                                                                                                    $Example_result._map_key = (System.Int32).Call $reader.ReadInt8();
                                                                                                    .Default(System.Void);
                                                                                                    $Example_result._map_value = .Call $reader.ReadDouble();
                                                                                                    ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                                }
                                                                                            } .Else {
                                                                                                .Break end { }
                                                                                            }
                                                                                        }
                                                                                        .LabelTarget end:
                                                                                    }
                                                                                } .Else {
                                                                                    .If ($valueType == .Constant<Bond.BondDataType>(BT_FLOAT)) {
                                                                                        .Block(
                                                                                            System.Int32 $Example_result._map_key,
                                                                                            System.Double $Example_result._map_value) {
                                                                                            .Default(System.Void);
                                                                                            .Loop  {
                                                                                                .If ($count-- > 0) {
                                                                                                    .Block() {
                                                                                                        $Example_result._map_key = (System.Int32).Call $reader.ReadInt8();
                                                                                                        .Default(System.Void);
                                                                                                        $Example_result._map_value = (System.Double).Call $reader.ReadFloat();
                                                                                                        ($Example_result._map).Item[$Example_result._map_key] = $Example_result._map_value
                                                                                                    }
                                                                                                } .Else {
                                                                                                    .Break end { }
                                                                                                }
                                                                                            }
                                                                                            .LabelTarget end:
                                                                                        }
                                                                                    } .Else {
                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                            .Constant<Bond.BondDataType>(BT_DOUBLE),
                                                                                            $valueType)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_INT32),
                                                                                    $keyType)
                                                                            }
                                                                        }
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_MAP),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(60)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(60)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(70)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                        $Example_result._decimal = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                            .Call $reader.ReadBytes($count),
                                                                            .Default(System.Decimal))
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(70)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(70)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(71)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(System.Decimal $Example_result._decList_item) {
                                                                            .Default(System.Void);
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._decList_item = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                .Call $reader.ReadBytes($count),
                                                                                                                .Default(System.Decimal))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._decList).Add($Example_result._decList_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(71)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(71)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(72)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(System.Decimal $Example_result._decVector_item) {
                                                                            .Block(System.Int32 $Example_result._decVector_count) {
                                                                                $Example_result._decVector_count = $count;
                                                                                .If ($Example_result._decVector_count > 65536) {
                                                                                    $Example_result._decVector_count = 65536
                                                                                } .Else {
                                                                                    .Default(System.Void)
                                                                                };
                                                                                ($Example_result._decVector).Capacity = $Example_result._decVector_count
                                                                            };
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._decVector_item = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                .Call $reader.ReadBytes($count),
                                                                                                                .Default(System.Decimal))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._decVector).Add($Example_result._decVector_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(72)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(72)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(73)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_MAP)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $keyType,
                                                                    Bond.BondDataType $valueType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $keyType,
                                                                        $valueType);
                                                                    .If ($keyType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                        .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                            .Block(
                                                                                System.Int32 $Example_result._decMap_key,
                                                                                System.Decimal $Example_result._decMap_value) {
                                                                                .Default(System.Void);
                                                                                .Loop  {
                                                                                    .If ($count-- > 0) {
                                                                                        .Block() {
                                                                                            $Example_result._decMap_key = .Call $reader.ReadInt32();
                                                                                            .Default(System.Void);
                                                                                            .Block(System.Int32 $depth) {
                                                                                                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                .Try {
                                                                                                    .Block() {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                        .Block(
                                                                                                            System.Int32 $count,
                                                                                                            Bond.BondDataType $elementType) {
                                                                                                            .Call $reader.ReadContainerBegin(
                                                                                                                $count,
                                                                                                                $elementType);
                                                                                                            .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                $Example_result._decMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                    .Call $reader.ReadBytes($count),
                                                                                                                    .Default(System.Decimal))
                                                                                                            } .Else {
                                                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                    .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                    $elementType)
                                                                                                            };
                                                                                                            .Call $reader.ReadContainerEnd()
                                                                                                        }
                                                                                                    }
                                                                                                } .Finally {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                }
                                                                                            };
                                                                                            ($Example_result._decMap).Item[$Example_result._decMap_key] = $Example_result._decMap_value
                                                                                        }
                                                                                    } .Else {
                                                                                        .Break end { }
                                                                                    }
                                                                                }
                                                                                .LabelTarget end:
                                                                            }
                                                                        } .Else {
                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                .Constant<Bond.BondDataType>(BT_LIST),
                                                                                $valueType)
                                                                        }
                                                                    } .Else {
                                                                        .If ($keyType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                            .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                .Block(
                                                                                    System.Int32 $Example_result._decMap_key,
                                                                                    System.Decimal $Example_result._decMap_value) {
                                                                                    .Default(System.Void);
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._decMap_key = (System.Int32).Call $reader.ReadInt16();
                                                                                                .Default(System.Void);
                                                                                                .Block(System.Int32 $depth) {
                                                                                                    $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                    .Try {
                                                                                                        .Block() {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                            .Block(
                                                                                                                System.Int32 $count,
                                                                                                                Bond.BondDataType $elementType) {
                                                                                                                .Call $reader.ReadContainerBegin(
                                                                                                                    $count,
                                                                                                                    $elementType);
                                                                                                                .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                    $Example_result._decMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                        .Call $reader.ReadBytes($count),
                                                                                                                        .Default(System.Decimal))
                                                                                                                } .Else {
                                                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                        .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                        $elementType)
                                                                                                                };
                                                                                                                .Call $reader.ReadContainerEnd()
                                                                                                            }
                                                                                                        }
                                                                                                    } .Finally {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                    }
                                                                                                };
                                                                                                ($Example_result._decMap).Item[$Example_result._decMap_key] = $Example_result._decMap_value
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_LIST),
                                                                                    $valueType)
                                                                            }
                                                                        } .Else {
                                                                            .If ($keyType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                    .Block(
                                                                                        System.Int32 $Example_result._decMap_key,
                                                                                        System.Decimal $Example_result._decMap_value) {
                                                                                        .Default(System.Void);
                                                                                        .Loop  {
                                                                                            .If ($count-- > 0) {
                                                                                                .Block() {
                                                                                                    $Example_result._decMap_key = (System.Int32).Call $reader.ReadInt8();
                                                                                                    .Default(System.Void);
                                                                                                    .Block(System.Int32 $depth) {
                                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                        .Try {
                                                                                                            .Block() {
                                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                                .Block(
                                                                                                                    System.Int32 $count,
                                                                                                                    Bond.BondDataType $elementType) {
                                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                                        $count,
                                                                                                                        $elementType);
                                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                        $Example_result._decMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                            .Call $reader.ReadBytes($count),
                                                                                                                            .Default(System.Decimal))
                                                                                                                    } .Else {
                                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                            $elementType)
                                                                                                                    };
                                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                                }
                                                                                                            }
                                                                                                        } .Finally {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                        }
                                                                                                    };
                                                                                                    ($Example_result._decMap).Item[$Example_result._decMap_key] = $Example_result._decMap_value
                                                                                                }
                                                                                            } .Else {
                                                                                                .Break end { }
                                                                                            }
                                                                                        }
                                                                                        .LabelTarget end:
                                                                                    }
                                                                                } .Else {
                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                                                        $valueType)
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_INT32),
                                                                                    $keyType)
                                                                            }
                                                                        }
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_MAP),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(73)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(73)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(74)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block() {
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block(System.Int32 $depth) {
                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                        .Try {
                                                                                            .Block() {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                .Block(
                                                                                                    System.Int32 $count,
                                                                                                    Bond.BondDataType $elementType) {
                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                        $count,
                                                                                                        $elementType);
                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                        $Example_result._decNullable = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                            .Call $reader.ReadBytes($count),
                                                                                                            .Default(System.Decimal))
                                                                                                    } .Else {
                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                            $elementType)
                                                                                                    };
                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                }
                                                                                            }
                                                                                        } .Finally {
                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                        }
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(74)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(74)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(75)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                        $Example_result._decimal_req = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                            .Call $reader.ReadBytes($count),
                                                                            .Default(System.Decimal))
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(75)) {
                                                .Block() {
                                                    .Invoke (.Lambda #Lambda3<System.Action`2[System.String,System.String]>)(
                                                        "Example",
                                                        "_decimal_req");
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(75)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Invoke (.Lambda #Lambda3<System.Action`2[System.String,System.String]>)(
                                            "Example",
                                            "_decimal_req");
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(80)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                        $Example_result._reference = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                            .Call $reader.ReadBytes($count),
                                                                            .Default(ExpressionsTest.RefObject))
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(80)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(80)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(81)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(ExpressionsTest.RefObject $Example_result._refList_item) {
                                                                            .Default(System.Void);
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._refList_item = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                .Call $reader.ReadBytes($count),
                                                                                                                .Default(ExpressionsTest.RefObject))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._refList).Add($Example_result._refList_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(81)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(81)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(82)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block(ExpressionsTest.RefObject $Example_result._refVector_item) {
                                                                            .Block(System.Int32 $Example_result._refVector_count) {
                                                                                $Example_result._refVector_count = $count;
                                                                                .If ($Example_result._refVector_count > 65536) {
                                                                                    $Example_result._refVector_count = 65536
                                                                                } .Else {
                                                                                    .Default(System.Void)
                                                                                };
                                                                                ($Example_result._refVector).Capacity = $Example_result._refVector_count
                                                                            };
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block() {
                                                                                        .Block(System.Int32 $depth) {
                                                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                            .Try {
                                                                                                .Block() {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                    .Block(
                                                                                                        System.Int32 $count,
                                                                                                        Bond.BondDataType $elementType) {
                                                                                                        .Call $reader.ReadContainerBegin(
                                                                                                            $count,
                                                                                                            $elementType);
                                                                                                        .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            $Example_result._refVector_item = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                .Call $reader.ReadBytes($count),
                                                                                                                .Default(ExpressionsTest.RefObject))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                $elementType)
                                                                                                        };
                                                                                                        .Call $reader.ReadContainerEnd()
                                                                                                    }
                                                                                                }
                                                                                            } .Finally {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                            }
                                                                                        };
                                                                                        .Call ($Example_result._refVector).Add($Example_result._refVector_item)
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:;
                                                                            .Default(System.Void)
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(82)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(82)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(83)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_MAP)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $keyType,
                                                                    Bond.BondDataType $valueType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $keyType,
                                                                        $valueType);
                                                                    .If ($keyType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                        .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                            .Block(
                                                                                System.Int32 $Example_result._refMap_key,
                                                                                ExpressionsTest.RefObject $Example_result._refMap_value) {
                                                                                .Default(System.Void);
                                                                                .Loop  {
                                                                                    .If ($count-- > 0) {
                                                                                        .Block() {
                                                                                            $Example_result._refMap_key = .Call $reader.ReadInt32();
                                                                                            .Default(System.Void);
                                                                                            .Block(System.Int32 $depth) {
                                                                                                $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                .Try {
                                                                                                    .Block() {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                        .Block(
                                                                                                            System.Int32 $count,
                                                                                                            Bond.BondDataType $elementType) {
                                                                                                            .Call $reader.ReadContainerBegin(
                                                                                                                $count,
                                                                                                                $elementType);
                                                                                                            .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                $Example_result._refMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                    .Call $reader.ReadBytes($count),
                                                                                                                    .Default(ExpressionsTest.RefObject))
                                                                                                            } .Else {
                                                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                    .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                    $elementType)
                                                                                                            };
                                                                                                            .Call $reader.ReadContainerEnd()
                                                                                                        }
                                                                                                    }
                                                                                                } .Finally {
                                                                                                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                }
                                                                                            };
                                                                                            ($Example_result._refMap).Item[$Example_result._refMap_key] = $Example_result._refMap_value
                                                                                        }
                                                                                    } .Else {
                                                                                        .Break end { }
                                                                                    }
                                                                                }
                                                                                .LabelTarget end:
                                                                            }
                                                                        } .Else {
                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                .Constant<Bond.BondDataType>(BT_LIST),
                                                                                $valueType)
                                                                        }
                                                                    } .Else {
                                                                        .If ($keyType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                            .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                .Block(
                                                                                    System.Int32 $Example_result._refMap_key,
                                                                                    ExpressionsTest.RefObject $Example_result._refMap_value) {
                                                                                    .Default(System.Void);
                                                                                    .Loop  {
                                                                                        .If ($count-- > 0) {
                                                                                            .Block() {
                                                                                                $Example_result._refMap_key = (System.Int32).Call $reader.ReadInt16();
                                                                                                .Default(System.Void);
                                                                                                .Block(System.Int32 $depth) {
                                                                                                    $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                    .Try {
                                                                                                        .Block() {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                            .Block(
                                                                                                                System.Int32 $count,
                                                                                                                Bond.BondDataType $elementType) {
                                                                                                                .Call $reader.ReadContainerBegin(
                                                                                                                    $count,
                                                                                                                    $elementType);
                                                                                                                .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                    $Example_result._refMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                        .Call $reader.ReadBytes($count),
                                                                                                                        .Default(ExpressionsTest.RefObject))
                                                                                                                } .Else {
                                                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                        .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                        $elementType)
                                                                                                                };
                                                                                                                .Call $reader.ReadContainerEnd()
                                                                                                            }
                                                                                                        }
                                                                                                    } .Finally {
                                                                                                        .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                    }
                                                                                                };
                                                                                                ($Example_result._refMap).Item[$Example_result._refMap_key] = $Example_result._refMap_value
                                                                                            }
                                                                                        } .Else {
                                                                                            .Break end { }
                                                                                        }
                                                                                    }
                                                                                    .LabelTarget end:
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_LIST),
                                                                                    $valueType)
                                                                            }
                                                                        } .Else {
                                                                            .If ($keyType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                .If ($valueType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                                    .Block(
                                                                                        System.Int32 $Example_result._refMap_key,
                                                                                        ExpressionsTest.RefObject $Example_result._refMap_value) {
                                                                                        .Default(System.Void);
                                                                                        .Loop  {
                                                                                            .If ($count-- > 0) {
                                                                                                .Block() {
                                                                                                    $Example_result._refMap_key = (System.Int32).Call $reader.ReadInt8();
                                                                                                    .Default(System.Void);
                                                                                                    .Block(System.Int32 $depth) {
                                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                                        .Try {
                                                                                                            .Block() {
                                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                                .Block(
                                                                                                                    System.Int32 $count,
                                                                                                                    Bond.BondDataType $elementType) {
                                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                                        $count,
                                                                                                                        $elementType);
                                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                                        $Example_result._refMap_value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                            .Call $reader.ReadBytes($count),
                                                                                                                            .Default(ExpressionsTest.RefObject))
                                                                                                                    } .Else {
                                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                                            $elementType)
                                                                                                                    };
                                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                                }
                                                                                                            }
                                                                                                        } .Finally {
                                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                                        }
                                                                                                    };
                                                                                                    ($Example_result._refMap).Item[$Example_result._refMap_key] = $Example_result._refMap_value
                                                                                                }
                                                                                            } .Else {
                                                                                                .Break end { }
                                                                                            }
                                                                                        }
                                                                                        .LabelTarget end:
                                                                                    }
                                                                                } .Else {
                                                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                                                        $valueType)
                                                                                }
                                                                            } .Else {
                                                                                .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                    .Constant<Bond.BondDataType>(BT_INT32),
                                                                                    $keyType)
                                                                            }
                                                                        }
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_MAP),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(83)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(83)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(84)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                    .Block(System.Int32 $depth) {
                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                        .Try {
                                                            .Block() {
                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                .Block(
                                                                    System.Int32 $count,
                                                                    Bond.BondDataType $elementType) {
                                                                    .Call $reader.ReadContainerBegin(
                                                                        $count,
                                                                        $elementType);
                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_LIST)) {
                                                                        .Block() {
                                                                            $Example_result._refNullable = .Default(ExpressionsTest.RefObject);
                                                                            .Loop  {
                                                                                .If ($count-- > 0) {
                                                                                    .Block(System.Int32 $depth) {
                                                                                        $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                                                        .Try {
                                                                                            .Block() {
                                                                                                .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                                                .Block(
                                                                                                    System.Int32 $count,
                                                                                                    Bond.BondDataType $elementType) {
                                                                                                    .Call $reader.ReadContainerBegin(
                                                                                                        $count,
                                                                                                        $elementType);
                                                                                                    .If ($elementType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                        $Example_result._refNullable = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                            .Call $reader.ReadBytes($count),
                                                                                                            .Default(ExpressionsTest.RefObject))
                                                                                                    } .Else {
                                                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                            .Constant<Bond.BondDataType>(BT_INT8),
                                                                                                            $elementType)
                                                                                                    };
                                                                                                    .Call $reader.ReadContainerEnd()
                                                                                                }
                                                                                            }
                                                                                        } .Finally {
                                                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                                                        }
                                                                                    }
                                                                                } .Else {
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                            .LabelTarget end:
                                                                        }
                                                                    } .Else {
                                                                        .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                            .Constant<Bond.BondDataType>(BT_LIST),
                                                                            $elementType)
                                                                    };
                                                                    .Call $reader.ReadContainerEnd()
                                                                }
                                                            }
                                                        } .Finally {
                                                            .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_LIST),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(84)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(84)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(85)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_STRUCT)) {
                                                    .Block() {
                                                        .Block(System.Int32 $depth) {
                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                            .Try {
                                                                .Block() {
                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                    .Block(
                                                                        Bond.BondDataType $fieldType,
                                                                        System.UInt16 $fieldId) {
                                                                        .Call $reader.ReadStructBegin();
                                                                        .Default(System.Void);
                                                                        .Default(System.Void);
                                                                        .Call $reader.ReadFieldBegin(
                                                                            $fieldType,
                                                                            $fieldId);
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(0)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT64)) {
                                                                                                ($Example_result._dt).value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                    .Call $reader.ReadInt64(),
                                                                                                    .Default(System.DateTime))
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                                                    ($Example_result._dt).value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                        (System.Int64).Call $reader.ReadInt32(),
                                                                                                        .Default(System.DateTime))
                                                                                                } .Else {
                                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                                                        ($Example_result._dt).value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                            (System.Int64).Call $reader.ReadInt16(),
                                                                                                            .Default(System.DateTime))
                                                                                                    } .Else {
                                                                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            ($Example_result._dt).value = .Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                (System.Int64).Call $reader.ReadInt8(),
                                                                                                                .Default(System.DateTime))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT64),
                                                                                                                $fieldType)
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ($fieldType != .Constant<Bond.BondDataType>(BT_STOP)) {
                                                                                .Block() {
                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                                                                        .Default(System.Void)
                                                                                    } .Else {
                                                                                        .Block() {
                                                                                            .Call $reader.Skip($fieldType);
                                                                                            .Call $reader.ReadFieldEnd()
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId)
                                                                                }
                                                                            } .Else {
                                                                                .Break end { }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Call $reader.ReadStructEnd();
                                                                        .Default(System.Void)
                                                                    }
                                                                }
                                                            } .Finally {
                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                            }
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_STRUCT),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(85)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(85)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ((System.Int32)$fieldType > 1) {
                                    .Block() {
                                        .If ($fieldId == .Constant<System.UInt16>(86)) {
                                            .Block() {
                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_STRUCT)) {
                                                    .Block() {
                                                        .Block(System.Int32 $depth) {
                                                            $depth = .Call Bond.MaxDepthChecker.ValidateDepthForIncrement();
                                                            .Try {
                                                                .Block() {
                                                                    .Call Bond.MaxDepthChecker.SetDepth(.Increment($depth));
                                                                    .Block(
                                                                        Bond.BondDataType $fieldType,
                                                                        System.UInt16 $fieldId) {
                                                                        .Call $reader.ReadStructBegin();
                                                                        .Default(System.Void);
                                                                        .Default(System.Void);
                                                                        .Call $reader.ReadFieldBegin(
                                                                            $fieldType,
                                                                            $fieldId);
                                                                        .Loop  {
                                                                            .If ((System.Int32)$fieldType > 1) {
                                                                                .Block() {
                                                                                    .If ($fieldId == .Constant<System.UInt16>(0)) {
                                                                                        .Block() {
                                                                                            .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT64)) {
                                                                                                ($Example_result._dt2).value = (System.Nullable`1[System.DateTime]).Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                    (System.Int64)((System.Nullable`1[System.Int64]).Call $reader.ReadInt64()),
                                                                                                    .Default(System.DateTime))
                                                                                            } .Else {
                                                                                                .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT32)) {
                                                                                                    ($Example_result._dt2).value = (System.Nullable`1[System.DateTime]).Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                        (System.Int64)((System.Nullable`1[System.Int64]).Call $reader.ReadInt32()),
                                                                                                        .Default(System.DateTime))
                                                                                                } .Else {
                                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT16)) {
                                                                                                        ($Example_result._dt2).value = (System.Nullable`1[System.DateTime]).Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                            (System.Int64)((System.Nullable`1[System.Int64]).Call $reader.ReadInt16()),
                                                                                                            .Default(System.DateTime))
                                                                                                    } .Else {
                                                                                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_INT8)) {
                                                                                                            ($Example_result._dt2).value = (System.Nullable`1[System.DateTime]).Call ExpressionsTest.BondTypeAliasConverter.Convert(
                                                                                                                (System.Int64)((System.Nullable`1[System.Int64]).Call $reader.ReadInt8()),
                                                                                                                .Default(System.DateTime))
                                                                                                        } .Else {
                                                                                                            .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                                                                                .Constant<Bond.BondDataType>(BT_INT64),
                                                                                                                $fieldType)
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            };
                                                                                            .Call $reader.ReadFieldEnd();
                                                                                            .Call $reader.ReadFieldBegin(
                                                                                                $fieldType,
                                                                                                $fieldId);
                                                                                            .Break end { }
                                                                                        }
                                                                                    } .Else {
                                                                                        .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                            .Block() {
                                                                                                .Default(System.Void);
                                                                                                .Break end { }
                                                                                            }
                                                                                        } .Else {
                                                                                            .Call $reader.Skip($fieldType)
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldEnd();
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId);
                                                                                    .If ($fieldId > .Constant<System.UInt16>(0)) {
                                                                                        .Break end { }
                                                                                    } .Else {
                                                                                        .Default(System.Void)
                                                                                    }
                                                                                }
                                                                            } .Else {
                                                                                .Block() {
                                                                                    .Default(System.Void);
                                                                                    .Break end { }
                                                                                }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Loop  {
                                                                            .If ($fieldType != .Constant<Bond.BondDataType>(BT_STOP)) {
                                                                                .Block() {
                                                                                    .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                                                                        .Default(System.Void)
                                                                                    } .Else {
                                                                                        .Block() {
                                                                                            .Call $reader.Skip($fieldType);
                                                                                            .Call $reader.ReadFieldEnd()
                                                                                        }
                                                                                    };
                                                                                    .Call $reader.ReadFieldBegin(
                                                                                        $fieldType,
                                                                                        $fieldId)
                                                                                }
                                                                            } .Else {
                                                                                .Break end { }
                                                                            }
                                                                        }
                                                                        .LabelTarget end:;
                                                                        .Call $reader.ReadStructEnd();
                                                                        .Default(System.Void)
                                                                    }
                                                                }
                                                            } .Finally {
                                                                .Call Bond.MaxDepthChecker.SetDepth($depth)
                                                            }
                                                        }
                                                    }
                                                } .Else {
                                                    .Invoke (.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>)(
                                                        .Constant<Bond.BondDataType>(BT_STRUCT),
                                                        $fieldType)
                                                };
                                                .Call $reader.ReadFieldEnd();
                                                .Call $reader.ReadFieldBegin(
                                                    $fieldType,
                                                    $fieldId);
                                                .Break end { }
                                            }
                                        } .Else {
                                            .If ($fieldId > .Constant<System.UInt16>(86)) {
                                                .Block() {
                                                    .Default(System.Void);
                                                    .Break end { }
                                                }
                                            } .Else {
                                                .Call $reader.Skip($fieldType)
                                            }
                                        };
                                        .Call $reader.ReadFieldEnd();
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId);
                                        .If ($fieldId > .Constant<System.UInt16>(86)) {
                                            .Break end { }
                                        } .Else {
                                            .Default(System.Void)
                                        }
                                    }
                                } .Else {
                                    .Block() {
                                        .Default(System.Void);
                                        .Break end { }
                                    }
                                }
                            }
                            .LabelTarget end:;
                            .Loop  {
                                .If ($fieldType != .Constant<Bond.BondDataType>(BT_STOP)) {
                                    .Block() {
                                        .If ($fieldType == .Constant<Bond.BondDataType>(BT_STOP_BASE)) {
                                            .Default(System.Void)
                                        } .Else {
                                            .Block() {
                                                .Call $reader.Skip($fieldType);
                                                .Call $reader.ReadFieldEnd()
                                            }
                                        };
                                        .Call $reader.ReadFieldBegin(
                                            $fieldType,
                                            $fieldId)
                                    }
                                } .Else {
                                    .Break end { }
                                }
                            }
                            .LabelTarget end:;
                            .Call $reader.ReadStructEnd();
                            .Default(System.Void)
                        }
                    }
                } .Finally {
                    .Call Bond.MaxDepthChecker.SetDepth($depth)
                }
            }
        };
        (System.Object)$Example_result
    }
}

.Lambda #Lambda2<System.Action`2[Bond.BondDataType,Bond.BondDataType]>(
    Bond.BondDataType $e,
    Bond.BondDataType $a) {
    .Call Bond.Expressions.ThrowExpression.ThrowInvalidTypeException(
        $e,
        $a)
}

.Lambda #Lambda3<System.Action`2[System.String,System.String]>(
    System.String $s,
    System.String $f) {
    .Call Bond.Expressions.ThrowExpression.ThrowRequiredFieldMissingException(
        $s,
        $f)
}