rplc_opcua 0.12.4

// OPCUA for Rust
// SPDX-License-Identifier: MPL-2.0
// Copyright (C) 2017-2022 Adam Lock
// This file was autogenerated from Opc.Ua.NodeSet2.Part4.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 = "Default Binary";
    let node_id = NodeId::new(0, 310);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 308), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7665), &ReferenceTypeId::HasDescription, ReferenceDirection::Forward),
        (&NodeId::new(0, 76), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn add_object_76(address_space: &mut AddressSpace) {
    // Object
    let name = "Default Binary";
    let node_id = NodeId::new(0, 542);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 540), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 12721), &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, 545);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 543), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 548);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 546), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 551);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 549), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 554);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 552), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 557);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 555), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 560);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 558), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 563);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 561), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 566);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 564), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 569);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 567), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 333);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 331), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7686), &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, 572);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 570), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 575);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 573), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 579);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 577), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 582);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 580), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 585);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 583), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7929), &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, 588);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 586), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7932), &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, 591);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 589), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7935), &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, 594);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 592), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7938), &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, 597);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 595), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7941), &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, 600);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 598), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7944), &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, 603);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 601), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 7947), &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, 606);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 604), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 609);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 607), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&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, 612);
    let node = Object::new(&node_id, name, name, EventNotifier::empty());
    let _ = address_space.insert(node, Some(&[
        (&NodeId::new(0, 610), &ReferenceTypeId::HasEncoding, ReferenceDirection::Inverse),
        (&NodeId::new(0, 76), &ReferenceTypeId::HasTypeDefinition, ReferenceDirection::Forward),
    ]));
}