// This file is generated by rust-protobuf 2.14.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `fuzzer.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_14_0;

#[derive(PartialEq,Clone,Default)]
pub struct Fuzzed {
    // message fields
    builtin_addrs: ::protobuf::RepeatedField<::std::string::String>,
    genesis_account: ::protobuf::SingularPtrField<EOA>,
    blocks: ::protobuf::RepeatedField<Block>,
    is_debug_mode: ::std::option::Option<bool>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Fuzzed {
    fn default() -> &'a Fuzzed {
        <Fuzzed as ::protobuf::Message>::default_instance()
    }
}

impl Fuzzed {
    pub fn new() -> Fuzzed {
        ::std::default::Default::default()
    }

    // repeated string builtin_addrs = 1;


    pub fn get_builtin_addrs(&self) -> &[::std::string::String] {
        &self.builtin_addrs
    }
    pub fn clear_builtin_addrs(&mut self) {
        self.builtin_addrs.clear();
    }

    // Param is passed by value, moved
    pub fn set_builtin_addrs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.builtin_addrs = v;
    }

    // Mutable pointer to the field.
    pub fn mut_builtin_addrs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.builtin_addrs
    }

    // Take field
    pub fn take_builtin_addrs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.builtin_addrs, ::protobuf::RepeatedField::new())
    }

    // required .EOA genesis_account = 2;


    pub fn get_genesis_account(&self) -> &EOA {
        self.genesis_account.as_ref().unwrap_or_else(|| EOA::default_instance())
    }
    pub fn clear_genesis_account(&mut self) {
        self.genesis_account.clear();
    }

    pub fn has_genesis_account(&self) -> bool {
        self.genesis_account.is_some()
    }

    // Param is passed by value, moved
    pub fn set_genesis_account(&mut self, v: EOA) {
        self.genesis_account = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_genesis_account(&mut self) -> &mut EOA {
        if self.genesis_account.is_none() {
            self.genesis_account.set_default();
        }
        self.genesis_account.as_mut().unwrap()
    }

    // Take field
    pub fn take_genesis_account(&mut self) -> EOA {
        self.genesis_account.take().unwrap_or_else(|| EOA::new())
    }

    // repeated .Block blocks = 3;


    pub fn get_blocks(&self) -> &[Block] {
        &self.blocks
    }
    pub fn clear_blocks(&mut self) {
        self.blocks.clear();
    }

    // Param is passed by value, moved
    pub fn set_blocks(&mut self, v: ::protobuf::RepeatedField<Block>) {
        self.blocks = v;
    }

    // Mutable pointer to the field.
    pub fn mut_blocks(&mut self) -> &mut ::protobuf::RepeatedField<Block> {
        &mut self.blocks
    }

    // Take field
    pub fn take_blocks(&mut self) -> ::protobuf::RepeatedField<Block> {
        ::std::mem::replace(&mut self.blocks, ::protobuf::RepeatedField::new())
    }

    // required bool is_debug_mode = 4;


    pub fn get_is_debug_mode(&self) -> bool {
        self.is_debug_mode.unwrap_or(false)
    }
    pub fn clear_is_debug_mode(&mut self) {
        self.is_debug_mode = ::std::option::Option::None;
    }

    pub fn has_is_debug_mode(&self) -> bool {
        self.is_debug_mode.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_debug_mode(&mut self, v: bool) {
        self.is_debug_mode = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for Fuzzed {
    fn is_initialized(&self) -> bool {
        if self.genesis_account.is_none() {
            return false;
        }
        if self.is_debug_mode.is_none() {
            return false;
        }
        for v in &self.genesis_account {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.blocks {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.builtin_addrs)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.genesis_account)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.blocks)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_debug_mode = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.builtin_addrs {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        if let Some(ref v) = self.genesis_account.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.blocks {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(v) = self.is_debug_mode {
            my_size += 2;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.builtin_addrs {
            os.write_string(1, &v)?;
        };
        if let Some(ref v) = self.genesis_account.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.blocks {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(v) = self.is_debug_mode {
            os.write_bool(4, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Fuzzed {
        Fuzzed::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "builtin_addrs",
                    |m: &Fuzzed| { &m.builtin_addrs },
                    |m: &mut Fuzzed| { &mut m.builtin_addrs },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EOA>>(
                    "genesis_account",
                    |m: &Fuzzed| { &m.genesis_account },
                    |m: &mut Fuzzed| { &mut m.genesis_account },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Block>>(
                    "blocks",
                    |m: &Fuzzed| { &m.blocks },
                    |m: &mut Fuzzed| { &mut m.blocks },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "is_debug_mode",
                    |m: &Fuzzed| { &m.is_debug_mode },
                    |m: &mut Fuzzed| { &mut m.is_debug_mode },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Fuzzed>(
                    "Fuzzed",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Fuzzed {
        static mut instance: ::protobuf::lazy::Lazy<Fuzzed> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(Fuzzed::new)
        }
    }
}

impl ::protobuf::Clear for Fuzzed {
    fn clear(&mut self) {
        self.builtin_addrs.clear();
        self.genesis_account.clear();
        self.blocks.clear();
        self.is_debug_mode = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Fuzzed {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Fuzzed {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Block {
    // message fields
    number: ::std::option::Option<u64>,
    author: ::protobuf::SingularField<::std::string::String>,
    timestamp: ::std::option::Option<u64>,
    difficulty: ::std::option::Option<u64>,
    gas_limit: ::std::option::Option<u64>,
    transactions: ::protobuf::RepeatedField<Transaction>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Block {
    fn default() -> &'a Block {
        <Block as ::protobuf::Message>::default_instance()
    }
}

impl Block {
    pub fn new() -> Block {
        ::std::default::Default::default()
    }

    // required uint64 number = 1;


    pub fn get_number(&self) -> u64 {
        self.number.unwrap_or(0)
    }
    pub fn clear_number(&mut self) {
        self.number = ::std::option::Option::None;
    }

    pub fn has_number(&self) -> bool {
        self.number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number(&mut self, v: u64) {
        self.number = ::std::option::Option::Some(v);
    }

    // required string author = 2;


    pub fn get_author(&self) -> &str {
        match self.author.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_author(&mut self) {
        self.author.clear();
    }

    pub fn has_author(&self) -> bool {
        self.author.is_some()
    }

    // Param is passed by value, moved
    pub fn set_author(&mut self, v: ::std::string::String) {
        self.author = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_author(&mut self) -> &mut ::std::string::String {
        if self.author.is_none() {
            self.author.set_default();
        }
        self.author.as_mut().unwrap()
    }

    // Take field
    pub fn take_author(&mut self) -> ::std::string::String {
        self.author.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required uint64 timestamp = 3;


    pub fn get_timestamp(&self) -> u64 {
        self.timestamp.unwrap_or(0)
    }
    pub fn clear_timestamp(&mut self) {
        self.timestamp = ::std::option::Option::None;
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_timestamp(&mut self, v: u64) {
        self.timestamp = ::std::option::Option::Some(v);
    }

    // required uint64 difficulty = 4;


    pub fn get_difficulty(&self) -> u64 {
        self.difficulty.unwrap_or(0)
    }
    pub fn clear_difficulty(&mut self) {
        self.difficulty = ::std::option::Option::None;
    }

    pub fn has_difficulty(&self) -> bool {
        self.difficulty.is_some()
    }

    // Param is passed by value, moved
    pub fn set_difficulty(&mut self, v: u64) {
        self.difficulty = ::std::option::Option::Some(v);
    }

    // required uint64 gas_limit = 5;


    pub fn get_gas_limit(&self) -> u64 {
        self.gas_limit.unwrap_or(0)
    }
    pub fn clear_gas_limit(&mut self) {
        self.gas_limit = ::std::option::Option::None;
    }

    pub fn has_gas_limit(&self) -> bool {
        self.gas_limit.is_some()
    }

    // Param is passed by value, moved
    pub fn set_gas_limit(&mut self, v: u64) {
        self.gas_limit = ::std::option::Option::Some(v);
    }

    // repeated .Transaction transactions = 6;


    pub fn get_transactions(&self) -> &[Transaction] {
        &self.transactions
    }
    pub fn clear_transactions(&mut self) {
        self.transactions.clear();
    }

    // Param is passed by value, moved
    pub fn set_transactions(&mut self, v: ::protobuf::RepeatedField<Transaction>) {
        self.transactions = v;
    }

    // Mutable pointer to the field.
    pub fn mut_transactions(&mut self) -> &mut ::protobuf::RepeatedField<Transaction> {
        &mut self.transactions
    }

    // Take field
    pub fn take_transactions(&mut self) -> ::protobuf::RepeatedField<Transaction> {
        ::std::mem::replace(&mut self.transactions, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for Block {
    fn is_initialized(&self) -> bool {
        if self.number.is_none() {
            return false;
        }
        if self.author.is_none() {
            return false;
        }
        if self.timestamp.is_none() {
            return false;
        }
        if self.difficulty.is_none() {
            return false;
        }
        if self.gas_limit.is_none() {
            return false;
        }
        for v in &self.transactions {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.number = ::std::option::Option::Some(tmp);
                },
                2 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.author)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.timestamp = ::std::option::Option::Some(tmp);
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.difficulty = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.gas_limit = ::std::option::Option::Some(tmp);
                },
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.transactions)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(v) = self.number {
            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.author.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.timestamp {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.difficulty {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.gas_limit {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.transactions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(v) = self.number {
            os.write_uint64(1, v)?;
        }
        if let Some(ref v) = self.author.as_ref() {
            os.write_string(2, &v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_uint64(3, v)?;
        }
        if let Some(v) = self.difficulty {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.gas_limit {
            os.write_uint64(5, v)?;
        }
        for v in &self.transactions {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Block {
        Block::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "number",
                    |m: &Block| { &m.number },
                    |m: &mut Block| { &mut m.number },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "author",
                    |m: &Block| { &m.author },
                    |m: &mut Block| { &mut m.author },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "timestamp",
                    |m: &Block| { &m.timestamp },
                    |m: &mut Block| { &mut m.timestamp },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "difficulty",
                    |m: &Block| { &m.difficulty },
                    |m: &mut Block| { &mut m.difficulty },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "gas_limit",
                    |m: &Block| { &m.gas_limit },
                    |m: &mut Block| { &mut m.gas_limit },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Transaction>>(
                    "transactions",
                    |m: &Block| { &m.transactions },
                    |m: &mut Block| { &mut m.transactions },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Block>(
                    "Block",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Block {
        static mut instance: ::protobuf::lazy::Lazy<Block> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(Block::new)
        }
    }
}

impl ::protobuf::Clear for Block {
    fn clear(&mut self) {
        self.number = ::std::option::Option::None;
        self.author.clear();
        self.timestamp = ::std::option::Option::None;
        self.difficulty = ::std::option::Option::None;
        self.gas_limit = ::std::option::Option::None;
        self.transactions.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Block {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Block {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Transaction {
    // message fields
    sender: ::protobuf::SingularField<::std::string::String>,
    receiver: ::std::option::Option<u32>,
    receiver_debug: ::protobuf::SingularField<::std::string::String>,
    gas_price: ::std::option::Option<u64>,
    gas: ::std::option::Option<u64>,
    value: ::std::option::Option<u64>,
    is_create_tx: ::std::option::Option<bool>,
    call_tx_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    create_tx_constructor: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    create_tx_contract: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    create_tx_constructor_postfix: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    create_tx_contract_postfix: ::protobuf::SingularField<::std::vec::Vec<u8>>,
    tx_data_hex_debug: ::protobuf::SingularField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Transaction {
    fn default() -> &'a Transaction {
        <Transaction as ::protobuf::Message>::default_instance()
    }
}

impl Transaction {
    pub fn new() -> Transaction {
        ::std::default::Default::default()
    }

    // required string sender = 1;


    pub fn get_sender(&self) -> &str {
        match self.sender.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_sender(&mut self) {
        self.sender.clear();
    }

    pub fn has_sender(&self) -> bool {
        self.sender.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sender(&mut self, v: ::std::string::String) {
        self.sender = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sender(&mut self) -> &mut ::std::string::String {
        if self.sender.is_none() {
            self.sender.set_default();
        }
        self.sender.as_mut().unwrap()
    }

    // Take field
    pub fn take_sender(&mut self) -> ::std::string::String {
        self.sender.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint32 receiver = 2;


    pub fn get_receiver(&self) -> u32 {
        self.receiver.unwrap_or(0)
    }
    pub fn clear_receiver(&mut self) {
        self.receiver = ::std::option::Option::None;
    }

    pub fn has_receiver(&self) -> bool {
        self.receiver.is_some()
    }

    // Param is passed by value, moved
    pub fn set_receiver(&mut self, v: u32) {
        self.receiver = ::std::option::Option::Some(v);
    }

    // optional string receiver_debug = 3;


    pub fn get_receiver_debug(&self) -> &str {
        match self.receiver_debug.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_receiver_debug(&mut self) {
        self.receiver_debug.clear();
    }

    pub fn has_receiver_debug(&self) -> bool {
        self.receiver_debug.is_some()
    }

    // Param is passed by value, moved
    pub fn set_receiver_debug(&mut self, v: ::std::string::String) {
        self.receiver_debug = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_receiver_debug(&mut self) -> &mut ::std::string::String {
        if self.receiver_debug.is_none() {
            self.receiver_debug.set_default();
        }
        self.receiver_debug.as_mut().unwrap()
    }

    // Take field
    pub fn take_receiver_debug(&mut self) -> ::std::string::String {
        self.receiver_debug.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required uint64 gas_price = 4;


    pub fn get_gas_price(&self) -> u64 {
        self.gas_price.unwrap_or(0)
    }
    pub fn clear_gas_price(&mut self) {
        self.gas_price = ::std::option::Option::None;
    }

    pub fn has_gas_price(&self) -> bool {
        self.gas_price.is_some()
    }

    // Param is passed by value, moved
    pub fn set_gas_price(&mut self, v: u64) {
        self.gas_price = ::std::option::Option::Some(v);
    }

    // required uint64 gas = 5;


    pub fn get_gas(&self) -> u64 {
        self.gas.unwrap_or(0)
    }
    pub fn clear_gas(&mut self) {
        self.gas = ::std::option::Option::None;
    }

    pub fn has_gas(&self) -> bool {
        self.gas.is_some()
    }

    // Param is passed by value, moved
    pub fn set_gas(&mut self, v: u64) {
        self.gas = ::std::option::Option::Some(v);
    }

    // required uint64 value = 6;


    pub fn get_value(&self) -> u64 {
        self.value.unwrap_or(0)
    }
    pub fn clear_value(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

    // Param is passed by value, moved
    pub fn set_value(&mut self, v: u64) {
        self.value = ::std::option::Option::Some(v);
    }

    // required bool is_create_tx = 10;


    pub fn get_is_create_tx(&self) -> bool {
        self.is_create_tx.unwrap_or(false)
    }
    pub fn clear_is_create_tx(&mut self) {
        self.is_create_tx = ::std::option::Option::None;
    }

    pub fn has_is_create_tx(&self) -> bool {
        self.is_create_tx.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_create_tx(&mut self, v: bool) {
        self.is_create_tx = ::std::option::Option::Some(v);
    }

    // optional bytes call_tx_data = 11;


    pub fn get_call_tx_data(&self) -> &[u8] {
        match self.call_tx_data.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_call_tx_data(&mut self) {
        self.call_tx_data.clear();
    }

    pub fn has_call_tx_data(&self) -> bool {
        self.call_tx_data.is_some()
    }

    // Param is passed by value, moved
    pub fn set_call_tx_data(&mut self, v: ::std::vec::Vec<u8>) {
        self.call_tx_data = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_call_tx_data(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.call_tx_data.is_none() {
            self.call_tx_data.set_default();
        }
        self.call_tx_data.as_mut().unwrap()
    }

    // Take field
    pub fn take_call_tx_data(&mut self) -> ::std::vec::Vec<u8> {
        self.call_tx_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes create_tx_constructor = 12;


    pub fn get_create_tx_constructor(&self) -> &[u8] {
        match self.create_tx_constructor.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_create_tx_constructor(&mut self) {
        self.create_tx_constructor.clear();
    }

    pub fn has_create_tx_constructor(&self) -> bool {
        self.create_tx_constructor.is_some()
    }

    // Param is passed by value, moved
    pub fn set_create_tx_constructor(&mut self, v: ::std::vec::Vec<u8>) {
        self.create_tx_constructor = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_create_tx_constructor(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.create_tx_constructor.is_none() {
            self.create_tx_constructor.set_default();
        }
        self.create_tx_constructor.as_mut().unwrap()
    }

    // Take field
    pub fn take_create_tx_constructor(&mut self) -> ::std::vec::Vec<u8> {
        self.create_tx_constructor.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes create_tx_contract = 13;


    pub fn get_create_tx_contract(&self) -> &[u8] {
        match self.create_tx_contract.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_create_tx_contract(&mut self) {
        self.create_tx_contract.clear();
    }

    pub fn has_create_tx_contract(&self) -> bool {
        self.create_tx_contract.is_some()
    }

    // Param is passed by value, moved
    pub fn set_create_tx_contract(&mut self, v: ::std::vec::Vec<u8>) {
        self.create_tx_contract = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_create_tx_contract(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.create_tx_contract.is_none() {
            self.create_tx_contract.set_default();
        }
        self.create_tx_contract.as_mut().unwrap()
    }

    // Take field
    pub fn take_create_tx_contract(&mut self) -> ::std::vec::Vec<u8> {
        self.create_tx_contract.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes create_tx_constructor_postfix = 14;


    pub fn get_create_tx_constructor_postfix(&self) -> &[u8] {
        match self.create_tx_constructor_postfix.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_create_tx_constructor_postfix(&mut self) {
        self.create_tx_constructor_postfix.clear();
    }

    pub fn has_create_tx_constructor_postfix(&self) -> bool {
        self.create_tx_constructor_postfix.is_some()
    }

    // Param is passed by value, moved
    pub fn set_create_tx_constructor_postfix(&mut self, v: ::std::vec::Vec<u8>) {
        self.create_tx_constructor_postfix = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_create_tx_constructor_postfix(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.create_tx_constructor_postfix.is_none() {
            self.create_tx_constructor_postfix.set_default();
        }
        self.create_tx_constructor_postfix.as_mut().unwrap()
    }

    // Take field
    pub fn take_create_tx_constructor_postfix(&mut self) -> ::std::vec::Vec<u8> {
        self.create_tx_constructor_postfix.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional bytes create_tx_contract_postfix = 15;


    pub fn get_create_tx_contract_postfix(&self) -> &[u8] {
        match self.create_tx_contract_postfix.as_ref() {
            Some(v) => &v,
            None => &[],
        }
    }
    pub fn clear_create_tx_contract_postfix(&mut self) {
        self.create_tx_contract_postfix.clear();
    }

    pub fn has_create_tx_contract_postfix(&self) -> bool {
        self.create_tx_contract_postfix.is_some()
    }

    // Param is passed by value, moved
    pub fn set_create_tx_contract_postfix(&mut self, v: ::std::vec::Vec<u8>) {
        self.create_tx_contract_postfix = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_create_tx_contract_postfix(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.create_tx_contract_postfix.is_none() {
            self.create_tx_contract_postfix.set_default();
        }
        self.create_tx_contract_postfix.as_mut().unwrap()
    }

    // Take field
    pub fn take_create_tx_contract_postfix(&mut self) -> ::std::vec::Vec<u8> {
        self.create_tx_contract_postfix.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    // optional string tx_data_hex_debug = 16;


    pub fn get_tx_data_hex_debug(&self) -> &str {
        match self.tx_data_hex_debug.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_tx_data_hex_debug(&mut self) {
        self.tx_data_hex_debug.clear();
    }

    pub fn has_tx_data_hex_debug(&self) -> bool {
        self.tx_data_hex_debug.is_some()
    }

    // Param is passed by value, moved
    pub fn set_tx_data_hex_debug(&mut self, v: ::std::string::String) {
        self.tx_data_hex_debug = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tx_data_hex_debug(&mut self) -> &mut ::std::string::String {
        if self.tx_data_hex_debug.is_none() {
            self.tx_data_hex_debug.set_default();
        }
        self.tx_data_hex_debug.as_mut().unwrap()
    }

    // Take field
    pub fn take_tx_data_hex_debug(&mut self) -> ::std::string::String {
        self.tx_data_hex_debug.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for Transaction {
    fn is_initialized(&self) -> bool {
        if self.sender.is_none() {
            return false;
        }
        if self.gas_price.is_none() {
            return false;
        }
        if self.gas.is_none() {
            return false;
        }
        if self.value.is_none() {
            return false;
        }
        if self.is_create_tx.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.sender)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.receiver = ::std::option::Option::Some(tmp);
                },
                3 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.receiver_debug)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.gas_price = ::std::option::Option::Some(tmp);
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.gas = ::std::option::Option::Some(tmp);
                },
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.value = ::std::option::Option::Some(tmp);
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.is_create_tx = ::std::option::Option::Some(tmp);
                },
                11 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.call_tx_data)?;
                },
                12 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.create_tx_constructor)?;
                },
                13 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.create_tx_contract)?;
                },
                14 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.create_tx_constructor_postfix)?;
                },
                15 => {
                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.create_tx_contract_postfix)?;
                },
                16 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.tx_data_hex_debug)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.sender.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.receiver {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(ref v) = self.receiver_debug.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.gas_price {
            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.gas {
            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.value {
            my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.is_create_tx {
            my_size += 2;
        }
        if let Some(ref v) = self.call_tx_data.as_ref() {
            my_size += ::protobuf::rt::bytes_size(11, &v);
        }
        if let Some(ref v) = self.create_tx_constructor.as_ref() {
            my_size += ::protobuf::rt::bytes_size(12, &v);
        }
        if let Some(ref v) = self.create_tx_contract.as_ref() {
            my_size += ::protobuf::rt::bytes_size(13, &v);
        }
        if let Some(ref v) = self.create_tx_constructor_postfix.as_ref() {
            my_size += ::protobuf::rt::bytes_size(14, &v);
        }
        if let Some(ref v) = self.create_tx_contract_postfix.as_ref() {
            my_size += ::protobuf::rt::bytes_size(15, &v);
        }
        if let Some(ref v) = self.tx_data_hex_debug.as_ref() {
            my_size += ::protobuf::rt::string_size(16, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.sender.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.receiver {
            os.write_uint32(2, v)?;
        }
        if let Some(ref v) = self.receiver_debug.as_ref() {
            os.write_string(3, &v)?;
        }
        if let Some(v) = self.gas_price {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.gas {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.value {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.is_create_tx {
            os.write_bool(10, v)?;
        }
        if let Some(ref v) = self.call_tx_data.as_ref() {
            os.write_bytes(11, &v)?;
        }
        if let Some(ref v) = self.create_tx_constructor.as_ref() {
            os.write_bytes(12, &v)?;
        }
        if let Some(ref v) = self.create_tx_contract.as_ref() {
            os.write_bytes(13, &v)?;
        }
        if let Some(ref v) = self.create_tx_constructor_postfix.as_ref() {
            os.write_bytes(14, &v)?;
        }
        if let Some(ref v) = self.create_tx_contract_postfix.as_ref() {
            os.write_bytes(15, &v)?;
        }
        if let Some(ref v) = self.tx_data_hex_debug.as_ref() {
            os.write_string(16, &v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Transaction {
        Transaction::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "sender",
                    |m: &Transaction| { &m.sender },
                    |m: &mut Transaction| { &mut m.sender },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "receiver",
                    |m: &Transaction| { &m.receiver },
                    |m: &mut Transaction| { &mut m.receiver },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "receiver_debug",
                    |m: &Transaction| { &m.receiver_debug },
                    |m: &mut Transaction| { &mut m.receiver_debug },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "gas_price",
                    |m: &Transaction| { &m.gas_price },
                    |m: &mut Transaction| { &mut m.gas_price },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "gas",
                    |m: &Transaction| { &m.gas },
                    |m: &mut Transaction| { &mut m.gas },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "value",
                    |m: &Transaction| { &m.value },
                    |m: &mut Transaction| { &mut m.value },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "is_create_tx",
                    |m: &Transaction| { &m.is_create_tx },
                    |m: &mut Transaction| { &mut m.is_create_tx },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "call_tx_data",
                    |m: &Transaction| { &m.call_tx_data },
                    |m: &mut Transaction| { &mut m.call_tx_data },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "create_tx_constructor",
                    |m: &Transaction| { &m.create_tx_constructor },
                    |m: &mut Transaction| { &mut m.create_tx_constructor },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "create_tx_contract",
                    |m: &Transaction| { &m.create_tx_contract },
                    |m: &mut Transaction| { &mut m.create_tx_contract },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "create_tx_constructor_postfix",
                    |m: &Transaction| { &m.create_tx_constructor_postfix },
                    |m: &mut Transaction| { &mut m.create_tx_constructor_postfix },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "create_tx_contract_postfix",
                    |m: &Transaction| { &m.create_tx_contract_postfix },
                    |m: &mut Transaction| { &mut m.create_tx_contract_postfix },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tx_data_hex_debug",
                    |m: &Transaction| { &m.tx_data_hex_debug },
                    |m: &mut Transaction| { &mut m.tx_data_hex_debug },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Transaction>(
                    "Transaction",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Transaction {
        static mut instance: ::protobuf::lazy::Lazy<Transaction> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(Transaction::new)
        }
    }
}

impl ::protobuf::Clear for Transaction {
    fn clear(&mut self) {
        self.sender.clear();
        self.receiver = ::std::option::Option::None;
        self.receiver_debug.clear();
        self.gas_price = ::std::option::Option::None;
        self.gas = ::std::option::Option::None;
        self.value = ::std::option::Option::None;
        self.is_create_tx = ::std::option::Option::None;
        self.call_tx_data.clear();
        self.create_tx_constructor.clear();
        self.create_tx_contract.clear();
        self.create_tx_constructor_postfix.clear();
        self.create_tx_contract_postfix.clear();
        self.tx_data_hex_debug.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Transaction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Transaction {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct EOA {
    // message fields
    address: ::protobuf::SingularField<::std::string::String>,
    balance: ::std::option::Option<u64>,
    nonce: ::std::option::Option<u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a EOA {
    fn default() -> &'a EOA {
        <EOA as ::protobuf::Message>::default_instance()
    }
}

impl EOA {
    pub fn new() -> EOA {
        ::std::default::Default::default()
    }

    // required string address = 1;


    pub fn get_address(&self) -> &str {
        match self.address.as_ref() {
            Some(v) => &v,
            None => "",
        }
    }
    pub fn clear_address(&mut self) {
        self.address.clear();
    }

    pub fn has_address(&self) -> bool {
        self.address.is_some()
    }

    // Param is passed by value, moved
    pub fn set_address(&mut self, v: ::std::string::String) {
        self.address = ::protobuf::SingularField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address(&mut self) -> &mut ::std::string::String {
        if self.address.is_none() {
            self.address.set_default();
        }
        self.address.as_mut().unwrap()
    }

    // Take field
    pub fn take_address(&mut self) -> ::std::string::String {
        self.address.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required uint64 balance = 2;


    pub fn get_balance(&self) -> u64 {
        self.balance.unwrap_or(0)
    }
    pub fn clear_balance(&mut self) {
        self.balance = ::std::option::Option::None;
    }

    pub fn has_balance(&self) -> bool {
        self.balance.is_some()
    }

    // Param is passed by value, moved
    pub fn set_balance(&mut self, v: u64) {
        self.balance = ::std::option::Option::Some(v);
    }

    // required uint64 nonce = 3;


    pub fn get_nonce(&self) -> u64 {
        self.nonce.unwrap_or(0)
    }
    pub fn clear_nonce(&mut self) {
        self.nonce = ::std::option::Option::None;
    }

    pub fn has_nonce(&self) -> bool {
        self.nonce.is_some()
    }

    // Param is passed by value, moved
    pub fn set_nonce(&mut self, v: u64) {
        self.nonce = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for EOA {
    fn is_initialized(&self) -> bool {
        if self.address.is_none() {
            return false;
        }
        if self.balance.is_none() {
            return false;
        }
        if self.nonce.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.address)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.balance = ::std::option::Option::Some(tmp);
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.nonce = ::std::option::Option::Some(tmp);
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.address.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.balance {
            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
        }
        if let Some(v) = self.nonce {
            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.address.as_ref() {
            os.write_string(1, &v)?;
        }
        if let Some(v) = self.balance {
            os.write_uint64(2, v)?;
        }
        if let Some(v) = self.nonce {
            os.write_uint64(3, v)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> EOA {
        EOA::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "address",
                    |m: &EOA| { &m.address },
                    |m: &mut EOA| { &mut m.address },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "balance",
                    |m: &EOA| { &m.balance },
                    |m: &mut EOA| { &mut m.balance },
                ));
                fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                    "nonce",
                    |m: &EOA| { &m.nonce },
                    |m: &mut EOA| { &mut m.nonce },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<EOA>(
                    "EOA",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static EOA {
        static mut instance: ::protobuf::lazy::Lazy<EOA> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(EOA::new)
        }
    }
}

impl ::protobuf::Clear for EOA {
    fn clear(&mut self) {
        self.address.clear();
        self.balance = ::std::option::Option::None;
        self.nonce = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for EOA {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for EOA {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct FuzzResult {
    // message fields
    roots: ::protobuf::RepeatedField<::std::string::String>,
    dumps: ::protobuf::RepeatedField<::std::string::String>,
    traces: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a FuzzResult {
    fn default() -> &'a FuzzResult {
        <FuzzResult as ::protobuf::Message>::default_instance()
    }
}

impl FuzzResult {
    pub fn new() -> FuzzResult {
        ::std::default::Default::default()
    }

    // repeated string roots = 1;


    pub fn get_roots(&self) -> &[::std::string::String] {
        &self.roots
    }
    pub fn clear_roots(&mut self) {
        self.roots.clear();
    }

    // Param is passed by value, moved
    pub fn set_roots(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.roots = v;
    }

    // Mutable pointer to the field.
    pub fn mut_roots(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.roots
    }

    // Take field
    pub fn take_roots(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.roots, ::protobuf::RepeatedField::new())
    }

    // repeated string dumps = 2;


    pub fn get_dumps(&self) -> &[::std::string::String] {
        &self.dumps
    }
    pub fn clear_dumps(&mut self) {
        self.dumps.clear();
    }

    // Param is passed by value, moved
    pub fn set_dumps(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.dumps = v;
    }

    // Mutable pointer to the field.
    pub fn mut_dumps(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.dumps
    }

    // Take field
    pub fn take_dumps(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.dumps, ::protobuf::RepeatedField::new())
    }

    // repeated string traces = 3;


    pub fn get_traces(&self) -> &[::std::string::String] {
        &self.traces
    }
    pub fn clear_traces(&mut self) {
        self.traces.clear();
    }

    // Param is passed by value, moved
    pub fn set_traces(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.traces = v;
    }

    // Mutable pointer to the field.
    pub fn mut_traces(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.traces
    }

    // Take field
    pub fn take_traces(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.traces, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for FuzzResult {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.roots)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.dumps)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.traces)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.roots {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        for value in &self.dumps {
            my_size += ::protobuf::rt::string_size(2, &value);
        };
        for value in &self.traces {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.roots {
            os.write_string(1, &v)?;
        };
        for v in &self.dumps {
            os.write_string(2, &v)?;
        };
        for v in &self.traces {
            os.write_string(3, &v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> FuzzResult {
        FuzzResult::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "roots",
                    |m: &FuzzResult| { &m.roots },
                    |m: &mut FuzzResult| { &mut m.roots },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "dumps",
                    |m: &FuzzResult| { &m.dumps },
                    |m: &mut FuzzResult| { &mut m.dumps },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "traces",
                    |m: &FuzzResult| { &m.traces },
                    |m: &mut FuzzResult| { &mut m.traces },
                ));
                ::protobuf::reflect::MessageDescriptor::new_pb_name::<FuzzResult>(
                    "FuzzResult",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static FuzzResult {
        static mut instance: ::protobuf::lazy::Lazy<FuzzResult> = ::protobuf::lazy::Lazy::INIT;
        unsafe {
            instance.get(FuzzResult::new)
        }
    }
}

impl ::protobuf::Clear for FuzzResult {
    fn clear(&mut self) {
        self.roots.clear();
        self.dumps.clear();
        self.traces.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for FuzzResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for FuzzResult {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0cfuzzer.proto\"\xa0\x01\n\x06Fuzzed\x12#\n\rbuiltin_addrs\x18\x01\
    \x20\x03(\tR\x0cbuiltinAddrs\x12-\n\x0fgenesis_account\x18\x02\x20\x02(\
    \x0b2\x04.EOAR\x0egenesisAccount\x12\x1e\n\x06blocks\x18\x03\x20\x03(\
    \x0b2\x06.BlockR\x06blocks\x12\"\n\ris_debug_mode\x18\x04\x20\x02(\x08R\
    \x0bisDebugMode\"\xc4\x01\n\x05Block\x12\x16\n\x06number\x18\x01\x20\x02\
    (\x04R\x06number\x12\x16\n\x06author\x18\x02\x20\x02(\tR\x06author\x12\
    \x1c\n\ttimestamp\x18\x03\x20\x02(\x04R\ttimestamp\x12\x1e\n\ndifficulty\
    \x18\x04\x20\x02(\x04R\ndifficulty\x12\x1b\n\tgas_limit\x18\x05\x20\x02(\
    \x04R\x08gasLimit\x120\n\x0ctransactions\x18\x06\x20\x03(\x0b2\x0c.Trans\
    actionR\x0ctransactions\"\xfe\x03\n\x0bTransaction\x12\x16\n\x06sender\
    \x18\x01\x20\x02(\tR\x06sender\x12\x1a\n\x08receiver\x18\x02\x20\x01(\rR\
    \x08receiver\x12%\n\x0ereceiver_debug\x18\x03\x20\x01(\tR\rreceiverDebug\
    \x12\x1b\n\tgas_price\x18\x04\x20\x02(\x04R\x08gasPrice\x12\x10\n\x03gas\
    \x18\x05\x20\x02(\x04R\x03gas\x12\x14\n\x05value\x18\x06\x20\x02(\x04R\
    \x05value\x12\x20\n\x0cis_create_tx\x18\n\x20\x02(\x08R\nisCreateTx\x12\
    \x20\n\x0ccall_tx_data\x18\x0b\x20\x01(\x0cR\ncallTxData\x122\n\x15creat\
    e_tx_constructor\x18\x0c\x20\x01(\x0cR\x13createTxConstructor\x12,\n\x12\
    create_tx_contract\x18\r\x20\x01(\x0cR\x10createTxContract\x12A\n\x1dcre\
    ate_tx_constructor_postfix\x18\x0e\x20\x01(\x0cR\x1acreateTxConstructorP\
    ostfix\x12;\n\x1acreate_tx_contract_postfix\x18\x0f\x20\x01(\x0cR\x17cre\
    ateTxContractPostfix\x12)\n\x11tx_data_hex_debug\x18\x10\x20\x01(\tR\x0e\
    txDataHexDebug\"O\n\x03EOA\x12\x18\n\x07address\x18\x01\x20\x02(\tR\x07a\
    ddress\x12\x18\n\x07balance\x18\x02\x20\x02(\x04R\x07balance\x12\x14\n\
    \x05nonce\x18\x03\x20\x02(\x04R\x05nonce\"P\n\nFuzzResult\x12\x14\n\x05r\
    oots\x18\x01\x20\x03(\tR\x05roots\x12\x14\n\x05dumps\x18\x02\x20\x03(\tR\
    \x05dumps\x12\x16\n\x06traces\x18\x03\x20\x03(\tR\x06traces\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}
