opcua 0.12.0

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2024 Adam Lock
// This file was autogenerated from Opc.Ua.NodeSet2.Part14.xml by tools/schema/gen_address_space.js
// DO NOT EDIT THIS FILE

#[allow(unused_imports)]
use std::{convert::TryFrom, str::FromStr};

#[allow(unused_imports)]
use crate::{
    server::address_space::{types::*, EventNotifier},
    types::{
        service_types::Argument, DataTypeId, ExtensionObject, LocalizedText, NodeId,
        ReferenceTypeId, UAString, Variant, VariantTypeId,
    },
};

#[allow(unused_variables)]
pub fn populate_address_space(address_space: &mut AddressSpace) {
    add_object_1(address_space);
    add_object_2(address_space);
    add_object_3(address_space);
    add_object_4(address_space);
    add_object_5(address_space);
    add_object_6(address_space);
    add_object_7(address_space);
    add_object_8(address_space);
    add_object_9(address_space);
    add_object_10(address_space);
    add_object_11(address_space);
    add_object_12(address_space);
    add_object_13(address_space);
    add_object_14(address_space);
    add_object_15(address_space);
    add_object_16(address_space);
    add_object_17(address_space);
    add_object_18(address_space);
    add_object_19(address_space);
    add_object_20(address_space);
    add_object_21(address_space);
    add_object_22(address_space);
    add_object_23(address_space);
    add_object_24(address_space);
    add_object_25(address_space);
    add_object_26(address_space);
    add_object_27(address_space);
    add_object_28(address_space);
    add_object_29(address_space);
    add_object_30(address_space);
    add_object_31(address_space);
    add_object_32(address_space);
    add_object_33(address_space);
    add_object_34(address_space);
    add_object_35(address_space);
    add_object_36(address_space);
    add_object_37(address_space);
    add_object_38(address_space);
    add_object_39(address_space);
    add_object_40(address_space);
    add_object_41(address_space);
    add_object_42(address_space);
    add_object_43(address_space);
    add_object_44(address_space);
    add_object_45(address_space);
    add_object_46(address_space);
    add_object_47(address_space);
    add_object_48(address_space);
    add_object_49(address_space);
    add_object_50(address_space);
    add_object_51(address_space);
    add_object_52(address_space);
    add_object_53(address_space);
    add_object_54(address_space);
    add_object_55(address_space);
    add_object_56(address_space);
    add_object_57(address_space);
    add_object_58(address_space);
    add_object_59(address_space);
    add_object_60(address_space);
    add_object_61(address_space);
    add_object_62(address_space);
    add_object_63(address_space);
    add_object_64(address_space);
    add_object_65(address_space);
    add_object_66(address_space);
    add_object_67(address_space);
    add_object_68(address_space);
    add_object_69(address_space);
    add_object_70(address_space);
    add_object_71(address_space);
    add_object_72(address_space);
    add_object_73(address_space);
    add_object_74(address_space);
    add_object_75(address_space);
    add_object_76(address_space);
    add_object_77(address_space);
    add_object_78(address_space);
    add_object_79(address_space);
    add_object_80(address_space);
    add_object_81(address_space);
    add_object_82(address_space);
    add_object_83(address_space);
    add_object_84(address_space);
    add_object_85(address_space);
    add_object_86(address_space);
    add_object_87(address_space);
    add_object_88(address_space);
    add_object_89(address_space);
    add_object_90(address_space);
    add_object_91(address_space);
    add_object_92(address_space);
    add_object_93(address_space);
    add_object_94(address_space);
    add_object_95(address_space);
    add_object_96(address_space);
    add_object_97(address_space);
    add_object_98(address_space);
    add_object_99(address_space);
    add_object_100(address_space);
}

fn add_object_1(address_space: &mut AddressSpace) {
    // Object
    let name = "SecurityGroups";
    let node_id = NodeId::new(0, 15913);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15914),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15917),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15452),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15906),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_2(address_space: &mut AddressSpace) {
    // Object
    let name = "<SecurityGroupFolderName>";
    let node_id = NodeId::new(0, 15453);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15454),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15457),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15452),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15452),
                &ReferenceTypeId::Organizes,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_3(address_space: &mut AddressSpace) {
    // Object
    let name = "<SecurityGroupName>";
    let node_id = NodeId::new(0, 15459);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15460),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15010),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15011),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15012),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15043),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15471),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15452),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_4(address_space: &mut AddressSpace) {
    // Object
    let name = "<ConnectionName>";
    let node_id = NodeId::new(0, 14417);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14418),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17292),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17478),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14423),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14419),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14209),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_5(address_space: &mut AddressSpace) {
    // Object
    let name = "Address";
    let node_id = NodeId::new(0, 14423);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15533),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21145),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14417),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_6(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 14419);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14420),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14417),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_7(address_space: &mut AddressSpace) {
    // Object
    let name = "PublishedDataSets";
    let node_id = NodeId::new(0, 14434);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14477),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14416),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_8(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 15844);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15845),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14416),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_9(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 18715);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18716),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18717),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18722),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18727),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18728),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18729),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18760),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19732),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14416),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_10(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 18729);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18730),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18735),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18740),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18745),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18750),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18755),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18715),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_11(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 18760);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18761),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18763),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18765),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18767),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18715),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_12(address_space: &mut AddressSpace) {
    // Object
    let name = "PublishSubscribe";
    let node_id = NodeId::new(0, 14443);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15215),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15440),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15443),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17366),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17369),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17371),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17405),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17409),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17481),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 2253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14416),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_13(address_space: &mut AddressSpace) {
    // Object
    let name = "SecurityGroups";
    let node_id = NodeId::new(0, 15443);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15444),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15447),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15452),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14443),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_14(address_space: &mut AddressSpace) {
    // Object
    let name = "PublishedDataSets";
    let node_id = NodeId::new(0, 17371);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14477),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14443),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_15(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 17405);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17406),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14443),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_16(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 17409);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17410),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17411),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17416),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17421),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17422),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17423),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17457),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19732),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14443),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_17(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 17423);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17424),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17431),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17436),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17441),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17446),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17451),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17409),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_18(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 17457);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17458),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17460),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17462),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17464),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17409),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_19(address_space: &mut AddressSpace) {
    // Object
    let name = "<DataSetWriterName>";
    let node_id = NodeId::new(0, 15222);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 16720),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16721),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17482),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15223),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_20(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 15223);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15224),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15222),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_21(address_space: &mut AddressSpace) {
    // Object
    let name = "ExtensionFields";
    let node_id = NodeId::new(0, 15481);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15482),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15485),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15489),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14509),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_22(address_space: &mut AddressSpace) {
    // Object
    let name = "<DataSetFolderName>";
    let node_id = NodeId::new(0, 14478);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14479),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14482),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16842),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16881),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14485),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16884),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 16923),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14477),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14477),
                &ReferenceTypeId::Organizes,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_23(address_space: &mut AddressSpace) {
    // Object
    let name = "<PublishedDataSetName>";
    let node_id = NodeId::new(0, 14487);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14489),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15221),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14509),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14477),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_24(address_space: &mut AddressSpace) {
    // Object
    let name = "Address";
    let node_id = NodeId::new(0, 14221);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17202),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21145),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14209),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_25(address_space: &mut AddressSpace) {
    // Object
    let name = "TransportSettings";
    let node_id = NodeId::new(0, 17203);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17721),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14209),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_26(address_space: &mut AddressSpace) {
    // Object
    let name = "<WriterGroupName>";
    let node_id = NodeId::new(0, 17310);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17311),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17204),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17486),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17314),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17214),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17318),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17319),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17321),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17322),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17558),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17725),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_27(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 17314);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17315),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17310),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_28(address_space: &mut AddressSpace) {
    // Object
    let name = "<ReaderGroupName>";
    let node_id = NodeId::new(0, 17325);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17326),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17302),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17487),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17329),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17999),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_29(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 17329);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17330),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17325),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_30(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 14600);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14601),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14209),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_31(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 19241);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19242),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19243),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19248),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19253),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19254),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19255),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19286),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19786),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14209),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_32(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19255);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19256),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19261),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19266),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19271),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19276),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19281),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19241),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_33(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19286);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19287),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19241),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_34(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 15265);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15266),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14232),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_35(address_space: &mut AddressSpace) {
    // Object
    let name = "TransportSettings";
    let node_id = NodeId::new(0, 17741);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17997),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17725),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_36(address_space: &mut AddressSpace) {
    // Object
    let name = "MessageSettings";
    let node_id = NodeId::new(0, 17742);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17998),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17725),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_37(address_space: &mut AddressSpace) {
    // Object
    let name = "<DataSetWriterName>";
    let node_id = NodeId::new(0, 17743);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17744),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17745),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17490),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17749),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_38(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 17749);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17750),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17743),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_39(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 17812);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17813),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17814),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17819),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17824),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17825),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17826),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17858),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19834),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17725),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_40(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 17826);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17827),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17832),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17837),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17842),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17847),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17853),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17859),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17874),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17900),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17812),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_41(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 17858);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 17913),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17927),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17812),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_42(address_space: &mut AddressSpace) {
    // Object
    let name = "<DataSetReaderName>";
    let node_id = NodeId::new(0, 18076);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18077),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18078),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18079),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18080),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18081),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18082),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17560),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17562),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17492),
                &ReferenceTypeId::HasProperty,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18088),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21006),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 11508),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_43(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 18088);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 18089),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18076),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_44(address_space: &mut AddressSpace) {
    // Object
    let name = "SubscribedDataSet";
    let node_id = NodeId::new(0, 21006);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15108),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 18076),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_45(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 21015);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21016),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21017),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21022),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21027),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21028),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21029),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21060),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19903),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17999),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_46(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 21029);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21030),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21035),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21040),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21045),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21050),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21055),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21061),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21015),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_47(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 21060);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21076),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21078),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21015),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_48(address_space: &mut AddressSpace) {
    // Object
    let name = "TransportSettings";
    let node_id = NodeId::new(0, 21080);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21090),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17999),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_49(address_space: &mut AddressSpace) {
    // Object
    let name = "MessageSettings";
    let node_id = NodeId::new(0, 21081);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21091),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 17999),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_50(address_space: &mut AddressSpace) {
    // Object
    let name = "TransportSettings";
    let node_id = NodeId::new(0, 15303);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15305),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_51(address_space: &mut AddressSpace) {
    // Object
    let name = "MessageSettings";
    let node_id = NodeId::new(0, 21095);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21096),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_52(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 15299);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15300),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_53(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 19550);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19551),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19552),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19557),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19562),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19563),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19564),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19595),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19968),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15298),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_54(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19564);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19565),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19570),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19575),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19580),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19585),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19590),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19596),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19550),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_55(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19595);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19550),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_56(address_space: &mut AddressSpace) {
    // Object
    let name = "TransportSettings";
    let node_id = NodeId::new(0, 15311);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15319),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_57(address_space: &mut AddressSpace) {
    // Object
    let name = "MessageSettings";
    let node_id = NodeId::new(0, 21103);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 21104),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_58(address_space: &mut AddressSpace) {
    // Object
    let name = "Status";
    let node_id = NodeId::new(0, 15307);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15308),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 14643),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_59(address_space: &mut AddressSpace) {
    // Object
    let name = "Diagnostics";
    let node_id = NodeId::new(0, 19609);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19610),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19611),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19616),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19621),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19622),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19623),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19654),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20027),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 80),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_60(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19623);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19624),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19629),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19634),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19639),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19644),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19649),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19655),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19609),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_61(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19654);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19609),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_62(address_space: &mut AddressSpace) {
    // Object
    let name = "SubscribedDataSet";
    let node_id = NodeId::new(0, 15316);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15108),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15306),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_63(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19691);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19692),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19697),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19702),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19707),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19712),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19717),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19677),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_64(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19722);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19677),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_65(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19777);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19778),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19780),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19782),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19784),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19732),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_66(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19831);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19832),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19786),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_67(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19848);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19880),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19885),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19890),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19834),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_68(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19879);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19895),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19897),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19899),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19901),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19834),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_69(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19917);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19949),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19954),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19959),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19903),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_70(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 19948);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 19964),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19966),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19903),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_71(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 19982);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 20014),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19968),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_72(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 20013);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 20019),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20021),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20023),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20025),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 19968),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_73(address_space: &mut AddressSpace) {
    // Object
    let name = "Counters";
    let node_id = NodeId::new(0, 20041);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 20073),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20078),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20027),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_74(address_space: &mut AddressSpace) {
    // Object
    let name = "LiveValues";
    let node_id = NodeId::new(0, 20072);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 20083),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20085),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20087),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20089),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20091),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20093),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 58),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 20027),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_75(address_space: &mut AddressSpace) {
    // Object
    let name = "DiscoveryAddress";
    let node_id = NodeId::new(0, 15072);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15154),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 21145),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 78),
                &ReferenceTypeId::HasModellingRule,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 15064),
                &ReferenceTypeId::HasComponent,
                ReferenceDirection::Inverse,
            ),
        ]),
    );
}

fn add_object_76(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15676);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15534),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15741),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_77(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 125);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14525),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14855),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_78(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 126);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15487),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15599),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_79(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 127);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15488),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15602),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_80(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15421);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15005),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15501),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_81(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15422);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15006),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15521),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_82(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 124);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14523),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14849),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_83(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 14839);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14524),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14852),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_84(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 14847);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14593),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14876),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_85(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15677);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15578),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15766),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_86(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15678);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15580),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15769),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_87(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 14323);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 14273),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 14324),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_88(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15679);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15581),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15772),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_89(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15681);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15582),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15775),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_90(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15682);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15597),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15778),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_91(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15683);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15598),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15781),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_92(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15688);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15605),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15784),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_93(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15689);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15609),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15787),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_94(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 21150);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15480),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 21156),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_95(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15691);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15611),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15793),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_96(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15693);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15616),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15854),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_97(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15694);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15617),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15857),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_98(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 15695);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15618),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 15860),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_99(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 21151);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15502),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 21159),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}

fn add_object_100(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 21152);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(
        node,
        Some(&[
            (
                &NodeId::new(0, 15510),
                &ReferenceTypeId::HasEncoding,
                ReferenceDirection::Inverse,
            ),
            (
                &NodeId::new(0, 21162),
                &ReferenceTypeId::HasDescription,
                ReferenceDirection::Forward,
            ),
            (
                &NodeId::new(0, 76),
                &ReferenceTypeId::HasTypeDefinition,
                ReferenceDirection::Forward,
            ),
        ]),
    );
}