declare namespace _default {
    export namespace exchCode {
        namespace PF {
            let MIC: string;
            let operatingMIC: string;
        }
        namespace UP {
            let MIC_1: string;
            export { MIC_1 as MIC };
            let operatingMIC_1: string;
            export { operatingMIC_1 as operatingMIC };
        }
        namespace AQ {
            let MIC_2: string;
            export { MIC_2 as MIC };
            let operatingMIC_2: string;
            export { operatingMIC_2 as operatingMIC };
        }
        namespace QX {
            let MIC_3: string;
            export { MIC_3 as MIC };
            let operatingMIC_3: string;
            export { operatingMIC_3 as operatingMIC };
        }
        namespace EB {
            let MIC_4: string;
            export { MIC_4 as MIC };
            let operatingMIC_4: string;
            export { operatingMIC_4 as operatingMIC };
        }
        namespace UF {
            let MIC_5: string;
            export { MIC_5 as MIC };
            let operatingMIC_5: string;
            export { operatingMIC_5 as operatingMIC };
        }
        namespace VY {
            let MIC_6: string;
            export { MIC_6 as MIC };
            let operatingMIC_6: string;
            export { operatingMIC_6 as operatingMIC };
        }
        namespace RB {
            let MIC_7: string;
            export { MIC_7 as MIC };
            let operatingMIC_7: string;
            export { operatingMIC_7 as operatingMIC };
        }
        namespace XB {
            let MIC_8: string;
            export { MIC_8 as MIC };
            let operatingMIC_8: string;
            export { operatingMIC_8 as operatingMIC };
        }
        namespace K3 {
            let MIC_9: string;
            export { MIC_9 as MIC };
            let operatingMIC_9: string;
            export { operatingMIC_9 as operatingMIC };
        }
        namespace B3 {
            let MIC_10: string;
            export { MIC_10 as MIC };
            let operatingMIC_10: string;
            export { operatingMIC_10 as operatingMIC };
        }
        namespace RZ {
            let MIC_11: string;
            export { MIC_11 as MIC };
            let operatingMIC_11: string;
            export { operatingMIC_11 as operatingMIC };
        }
        namespace XV {
            let MIC_12: string;
            export { MIC_12 as MIC };
            let operatingMIC_12: string;
            export { operatingMIC_12 as operatingMIC };
        }
        namespace AZ {
            let MIC_13: string;
            export { MIC_13 as MIC };
            let operatingMIC_13: string;
            export { operatingMIC_13 as operatingMIC };
        }
        namespace BY {
            let MIC_14: string;
            export { MIC_14 as MIC };
            let operatingMIC_14: string;
            export { operatingMIC_14 as operatingMIC };
        }
        namespace UO {
            let MIC_15: string;
            export { MIC_15 as MIC };
            let operatingMIC_15: string;
            export { operatingMIC_15 as operatingMIC };
        }
        namespace AH {
            let MIC_16: string;
            export { MIC_16 as MIC };
            let operatingMIC_16: string;
            export { operatingMIC_16 as operatingMIC };
        }
        namespace JI {
            let MIC_17: string;
            export { MIC_17 as MIC };
            let operatingMIC_17: string;
            export { operatingMIC_17 as operatingMIC };
        }
        namespace IX {
            let MIC_18: string;
            export { MIC_18 as MIC };
            let operatingMIC_18: string;
            export { operatingMIC_18 as operatingMIC };
        }
        namespace TX {
            let MIC_19: string;
            export { MIC_19 as MIC };
            let operatingMIC_19: string;
            export { operatingMIC_19 as operatingMIC };
        }
        namespace DD {
            let MIC_20: string;
            export { MIC_20 as MIC };
            let operatingMIC_20: string;
            export { operatingMIC_20 as operatingMIC };
        }
        namespace DU {
            let MIC_21: string;
            export { MIC_21 as MIC };
            let operatingMIC_21: string;
            export { operatingMIC_21 as operatingMIC };
        }
        namespace QD {
            let MIC_22: string;
            export { MIC_22 as MIC };
            let operatingMIC_22: string;
            export { operatingMIC_22 as operatingMIC };
        }
        namespace VJ {
            let MIC_23: string;
            export { MIC_23 as MIC };
            let operatingMIC_23: string;
            export { operatingMIC_23 as operatingMIC };
        }
        namespace VK {
            let MIC_24: string;
            export { MIC_24 as MIC };
            let operatingMIC_24: string;
            export { operatingMIC_24 as operatingMIC };
        }
        namespace AA {
            let MIC_25: string;
            export { MIC_25 as MIC };
            let operatingMIC_25: string;
            export { operatingMIC_25 as operatingMIC };
        }
        namespace TE {
            let MIC_26: string;
            export { MIC_26 as MIC };
            let operatingMIC_26: string;
            export { operatingMIC_26 as operatingMIC };
        }
        namespace GW {
            let MIC_27: string;
            export { MIC_27 as MIC };
            let operatingMIC_27: string;
            export { operatingMIC_27 as operatingMIC };
        }
        namespace BW {
            let MIC_28: string;
            export { MIC_28 as MIC };
            let operatingMIC_28: string;
            export { operatingMIC_28 as operatingMIC };
        }
        namespace FF {
            let MIC_29: string;
            export { MIC_29 as MIC };
            let operatingMIC_29: string;
            export { operatingMIC_29 as operatingMIC };
        }
        namespace SF {
            let MIC_30: string;
            export { MIC_30 as MIC };
            let operatingMIC_30: string;
            export { operatingMIC_30 as operatingMIC };
        }
        namespace TL {
            let MIC_31: string;
            export { MIC_31 as MIC };
            let operatingMIC_31: string;
            export { operatingMIC_31 as operatingMIC };
        }
        namespace HM {
            let MIC_32: string;
            export { MIC_32 as MIC };
            let operatingMIC_32: string;
            export { operatingMIC_32 as operatingMIC };
        }
        namespace XT {
            let MIC_33: string;
            export { MIC_33 as MIC };
            let operatingMIC_33: string;
            export { operatingMIC_33 as operatingMIC };
        }
        namespace VH {
            let MIC_34: string;
            export { MIC_34 as MIC };
            let operatingMIC_34: string;
            export { operatingMIC_34 as operatingMIC };
        }
        namespace UI {
            let MIC_35: string;
            export { MIC_35 as MIC };
            let operatingMIC_35: string;
            export { operatingMIC_35 as operatingMIC };
        }
        namespace VF {
            let MIC_36: string;
            export { MIC_36 as MIC };
            let operatingMIC_36: string;
            export { operatingMIC_36 as operatingMIC };
        }
        namespace RF {
            let MIC_37: string;
            export { MIC_37 as MIC };
            let operatingMIC_37: string;
            export { operatingMIC_37 as operatingMIC };
        }
        namespace JD {
            let MIC_38: string;
            export { MIC_38 as MIC };
            let operatingMIC_38: string;
            export { operatingMIC_38 as operatingMIC };
        }
        namespace TK {
            let MIC_39: string;
            export { MIC_39 as MIC };
            let operatingMIC_39: string;
            export { operatingMIC_39 as operatingMIC };
        }
        namespace L3 {
            let MIC_40: string;
            export { MIC_40 as MIC };
            let operatingMIC_40: string;
            export { operatingMIC_40 as operatingMIC };
        }
        namespace DG {
            let MIC_41: string;
            export { MIC_41 as MIC };
            let operatingMIC_41: string;
            export { operatingMIC_41 as operatingMIC };
        }
        namespace MX {
            let MIC_42: string;
            export { MIC_42 as MIC };
            let operatingMIC_42: string;
            export { operatingMIC_42 as operatingMIC };
        }
        namespace TR {
            let MIC_43: string;
            export { MIC_43 as MIC };
            let operatingMIC_43: string;
            export { operatingMIC_43 as operatingMIC };
        }
        namespace IG {
            let MIC_44: string;
            export { MIC_44 as MIC };
            let operatingMIC_44: string;
            export { operatingMIC_44 as operatingMIC };
        }
        namespace MQ {
            let MIC_45: string;
            export { MIC_45 as MIC };
            let operatingMIC_45: string;
            export { operatingMIC_45 as operatingMIC };
        }
        namespace RX {
            let MIC_46: string;
            export { MIC_46 as MIC };
            let operatingMIC_46: string;
            export { operatingMIC_46 as operatingMIC };
        }
        namespace IM {
            let MIC_47: string;
            export { MIC_47 as MIC };
            let operatingMIC_47: string;
            export { operatingMIC_47 as operatingMIC };
        }
        namespace IF {
            let MIC_48: string;
            export { MIC_48 as MIC };
            let operatingMIC_48: string;
            export { operatingMIC_48 as operatingMIC };
        }
        namespace PD {
            let MIC_49: string;
            export { MIC_49 as MIC };
            let operatingMIC_49: string;
            export { operatingMIC_49 as operatingMIC };
        }
        namespace PG {
            let MIC_50: string;
            export { MIC_50 as MIC };
            let operatingMIC_50: string;
            export { operatingMIC_50 as operatingMIC };
        }
        namespace QF {
            let MIC_51: string;
            export { MIC_51 as MIC };
            let operatingMIC_51: string;
            export { operatingMIC_51 as operatingMIC };
        }
        namespace EI {
            let MIC_52: string;
            export { MIC_52 as MIC };
            let operatingMIC_52: string;
            export { operatingMIC_52 as operatingMIC };
        }
        namespace NS {
            let MIC_53: string;
            export { MIC_53 as MIC };
            let operatingMIC_53: string;
            export { operatingMIC_53 as operatingMIC };
        }
        namespace ES {
            let MIC_54: string;
            export { MIC_54 as MIC };
            let operatingMIC_54: string;
            export { operatingMIC_54 as operatingMIC };
        }
        namespace NQ {
            let MIC_55: string;
            export { MIC_55 as MIC };
            let operatingMIC_55: string;
            export { operatingMIC_55 as operatingMIC };
        }
        namespace TG {
            let MIC_56: string;
            export { MIC_56 as MIC };
            let operatingMIC_56: string;
            export { operatingMIC_56 as operatingMIC };
        }
        namespace UV {
            let MIC_57: string;
            export { MIC_57 as MIC };
            let operatingMIC_57: string;
            export { operatingMIC_57 as operatingMIC };
        }
        namespace PX {
            let MIC_58: string;
            export { MIC_58 as MIC };
            let operatingMIC_58: string;
            export { operatingMIC_58 as operatingMIC };
        }
        namespace UZ {
            let MIC_59: string;
            export { MIC_59 as MIC };
            let operatingMIC_59: string;
            export { operatingMIC_59 as operatingMIC };
        }
        namespace QU {
            let MIC_60: string;
            export { MIC_60 as MIC };
            let operatingMIC_60: string;
            export { operatingMIC_60 as operatingMIC };
        }
        namespace PQ {
            let MIC_61: string;
            export { MIC_61 as MIC };
            let operatingMIC_61: string;
            export { operatingMIC_61 as operatingMIC };
        }
        namespace CJ {
            let MIC_62: string;
            export { MIC_62 as MIC };
            let operatingMIC_62: string;
            export { operatingMIC_62 as operatingMIC };
        }
        namespace QM {
            let MIC_63: string;
            export { MIC_63 as MIC };
            let operatingMIC_63: string;
            export { operatingMIC_63 as operatingMIC };
        }
        namespace TT {
            let MIC_64: string;
            export { MIC_64 as MIC };
            let operatingMIC_64: string;
            export { operatingMIC_64 as operatingMIC };
        }
        namespace RW {
            let MIC_65: string;
            export { MIC_65 as MIC };
            let operatingMIC_65: string;
            export { operatingMIC_65 as operatingMIC };
        }
        namespace RR {
            let MIC_66: string;
            export { MIC_66 as MIC };
            let operatingMIC_66: string;
            export { operatingMIC_66 as operatingMIC };
        }
        namespace RT {
            let MIC_67: string;
            export { MIC_67 as MIC };
            let operatingMIC_67: string;
            export { operatingMIC_67 as operatingMIC };
        }
        namespace JE {
            let MIC_68: string;
            export { MIC_68 as MIC };
            let operatingMIC_68: string;
            export { operatingMIC_68 as operatingMIC };
        }
        namespace JW {
            let MIC_69: string;
            export { MIC_69 as MIC };
            let operatingMIC_69: string;
            export { operatingMIC_69 as operatingMIC };
        }
        namespace H1 {
            let MIC_70: string;
            export { MIC_70 as MIC };
            let operatingMIC_70: string;
            export { operatingMIC_70 as operatingMIC };
        }
        namespace S1 {
            let MIC_71: string;
            export { MIC_71 as MIC };
            let operatingMIC_71: string;
            export { operatingMIC_71 as operatingMIC };
        }
        namespace TY {
            let MIC_72: string;
            export { MIC_72 as MIC };
            let operatingMIC_72: string;
            export { operatingMIC_72 as operatingMIC };
        }
        namespace A0 {
            let MIC_73: string;
            export { MIC_73 as MIC };
            let operatingMIC_73: string;
            export { operatingMIC_73 as operatingMIC };
        }
        namespace SI {
            let MIC_74: string;
            export { MIC_74 as MIC };
            let operatingMIC_74: string;
            export { operatingMIC_74 as operatingMIC };
        }
        namespace H2 {
            let MIC_75: string;
            export { MIC_75 as MIC };
            let operatingMIC_75: string;
            export { operatingMIC_75 as operatingMIC };
        }
        namespace TJ {
            let MIC_76: string;
            export { MIC_76 as MIC };
            let operatingMIC_76: string;
            export { operatingMIC_76 as operatingMIC };
        }
        namespace MT {
            let MIC_77: string;
            export { MIC_77 as MIC };
            let operatingMIC_77: string;
            export { operatingMIC_77 as operatingMIC };
        }
        namespace SZ {
            let MIC_78: string;
            export { MIC_78 as MIC };
            let operatingMIC_78: string;
            export { operatingMIC_78 as operatingMIC };
        }
        namespace DX {
            let MIC_79: string;
            export { MIC_79 as MIC };
            let operatingMIC_79: string;
            export { operatingMIC_79 as operatingMIC };
        }
        namespace TQ {
            let MIC_80: string;
            export { MIC_80 as MIC };
            let operatingMIC_80: string;
            export { operatingMIC_80 as operatingMIC };
        }
        namespace TN {
            let MIC_81: string;
            export { MIC_81 as MIC };
            let operatingMIC_81: string;
            export { operatingMIC_81 as operatingMIC };
        }
        namespace AP {
            let MIC_82: string;
            export { MIC_82 as MIC };
            let operatingMIC_82: string;
            export { operatingMIC_82 as operatingMIC };
        }
        namespace UD {
            let MIC_83: string;
            export { MIC_83 as MIC };
            let operatingMIC_83: string;
            export { operatingMIC_83 as operatingMIC };
        }
        namespace DH {
            let MIC_84: string;
            export { MIC_84 as MIC };
            let operatingMIC_84: string;
            export { operatingMIC_84 as operatingMIC };
        }
        namespace AG {
            let MIC_85: string;
            export { MIC_85 as MIC };
            let operatingMIC_85: string;
            export { operatingMIC_85 as operatingMIC };
        }
        namespace JR {
            let MIC_86: string;
            export { MIC_86 as MIC };
            let operatingMIC_86: string;
            export { operatingMIC_86 as operatingMIC };
        }
        namespace NA {
            let MIC_87: string;
            export { MIC_87 as MIC };
            let operatingMIC_87: string;
            export { operatingMIC_87 as operatingMIC };
        }
        namespace AY {
            let MIC_88: string;
            export { MIC_88 as MIC };
            let operatingMIC_88: string;
            export { operatingMIC_88 as operatingMIC };
        }
        namespace UA {
            let MIC_89: string;
            export { MIC_89 as MIC };
            let operatingMIC_89: string;
            export { operatingMIC_89 as operatingMIC };
        }
        namespace AT {
            let MIC_90: string;
            export { MIC_90 as MIC };
            let operatingMIC_90: string;
            export { operatingMIC_90 as operatingMIC };
        }
        namespace GA {
            let MIC_91: string;
            export { MIC_91 as MIC };
            let operatingMIC_91: string;
            export { operatingMIC_91 as operatingMIC };
        }
        namespace TA {
            let MIC_92: string;
            export { MIC_92 as MIC };
            let operatingMIC_92: string;
            export { operatingMIC_92 as operatingMIC };
        }
        namespace BM {
            let MIC_93: string;
            export { MIC_93 as MIC };
            let operatingMIC_93: string;
            export { operatingMIC_93 as operatingMIC };
        }
        namespace BA {
            let MIC_94: string;
            export { MIC_94 as MIC };
            let operatingMIC_94: string;
            export { operatingMIC_94 as operatingMIC };
        }
        namespace BI {
            let MIC_95: string;
            export { MIC_95 as MIC };
            let operatingMIC_95: string;
            export { operatingMIC_95 as operatingMIC };
        }
        namespace SB {
            let MIC_96: string;
            export { MIC_96 as MIC };
            let operatingMIC_96: string;
            export { operatingMIC_96 as operatingMIC };
        }
        namespace CE {
            let MIC_97: string;
            export { MIC_97 as MIC };
            let operatingMIC_97: string;
            export { operatingMIC_97 as operatingMIC };
        }
        namespace AM {
            let MIC_98: string;
            export { MIC_98 as MIC };
            let operatingMIC_98: string;
            export { operatingMIC_98 as operatingMIC };
        }
        namespace HO {
            let MIC_99: string;
            export { MIC_99 as MIC };
            let operatingMIC_99: string;
            export { operatingMIC_99 as operatingMIC };
        }
        namespace BH {
            let MIC_100: string;
            export { MIC_100 as MIC };
            let operatingMIC_100: string;
            export { operatingMIC_100 as operatingMIC };
        }
        namespace SG {
            let MIC_101: string;
            export { MIC_101 as MIC };
            let operatingMIC_101: string;
            export { operatingMIC_101 as operatingMIC };
        }
        namespace GB {
            let MIC_102: string;
            export { MIC_102 as MIC };
            let operatingMIC_102: string;
            export { operatingMIC_102 as operatingMIC };
        }
        namespace LB {
            let MIC_103: string;
            export { MIC_103 as MIC };
            let operatingMIC_103: string;
            export { operatingMIC_103 as operatingMIC };
        }
        namespace SO {
            let MIC_104: string;
            export { MIC_104 as MIC };
            let operatingMIC_104: string;
            export { operatingMIC_104 as operatingMIC };
        }
        namespace TB {
            let MIC_105: string;
            export { MIC_105 as MIC };
            let operatingMIC_105: string;
            export { operatingMIC_105 as operatingMIC };
        }
        namespace BK {
            let MIC_106: string;
            export { MIC_106 as MIC };
            let operatingMIC_106: string;
            export { operatingMIC_106 as operatingMIC };
        }
        namespace CR {
            let MIC_107: string;
            export { MIC_107 as MIC };
            let operatingMIC_107: string;
            export { operatingMIC_107 as operatingMIC };
        }
        namespace CX {
            let MIC_108: string;
            export { MIC_108 as MIC };
            let operatingMIC_108: string;
            export { operatingMIC_108 as operatingMIC };
        }
        namespace VB {
            let MIC_109: string;
            export { MIC_109 as MIC };
            let operatingMIC_109: string;
            export { operatingMIC_109 as operatingMIC };
        }
        namespace IB {
            let MIC_110: string;
            export { MIC_110 as MIC };
            let operatingMIC_110: string;
            export { operatingMIC_110 as operatingMIC };
        }
        namespace UB {
            let MIC_111: string;
            export { MIC_111 as MIC };
            let operatingMIC_111: string;
            export { operatingMIC_111 as operatingMIC };
        }
        namespace BG {
            let MIC_112: string;
            export { MIC_112 as MIC };
            let operatingMIC_112: string;
            export { operatingMIC_112 as operatingMIC };
        }
        namespace SK {
            let MIC_113: string;
            export { MIC_113 as MIC };
            let operatingMIC_113: string;
            export { operatingMIC_113 as operatingMIC };
        }
        namespace SR {
            let MIC_114: string;
            export { MIC_114 as MIC };
            let operatingMIC_114: string;
            export { operatingMIC_114 as operatingMIC };
        }
        namespace BB {
            let MIC_115: string;
            export { MIC_115 as MIC };
            let operatingMIC_115: string;
            export { operatingMIC_115 as operatingMIC };
        }
        namespace IA {
            let MIC_116: string;
            export { MIC_116 as MIC };
            let operatingMIC_116: string;
            export { operatingMIC_116 as operatingMIC };
        }
        namespace RE {
            let MIC_117: string;
            export { MIC_117 as MIC };
            let operatingMIC_117: string;
            export { operatingMIC_117 as operatingMIC };
        }
        namespace HB {
            let MIC_118: string;
            export { MIC_118 as MIC };
            let operatingMIC_118: string;
            export { operatingMIC_118 as operatingMIC };
        }
        namespace AF {
            let MIC_119: string;
            export { MIC_119 as MIC };
            let operatingMIC_119: string;
            export { operatingMIC_119 as operatingMIC };
        }
        namespace BU {
            let MIC_120: string;
            export { MIC_120 as MIC };
            let operatingMIC_120: string;
            export { operatingMIC_120 as operatingMIC };
        }
        namespace VR {
            let MIC_121: string;
            export { MIC_121 as MIC };
            let operatingMIC_121: string;
            export { operatingMIC_121 as operatingMIC };
        }
        namespace EC {
            let MIC_122: string;
            export { MIC_122 as MIC };
            let operatingMIC_122: string;
            export { operatingMIC_122 as operatingMIC };
        }
        namespace VS {
            let MIC_123: string;
            export { MIC_123 as MIC };
            let operatingMIC_123: string;
            export { operatingMIC_123 as operatingMIC };
        }
        namespace MC {
            let MIC_124: string;
            export { MIC_124 as MIC };
            let operatingMIC_124: string;
            export { operatingMIC_124 as operatingMIC };
        }
        namespace KY {
            let MIC_125: string;
            export { MIC_125 as MIC };
            let operatingMIC_125: string;
            export { operatingMIC_125 as operatingMIC };
        }
        namespace UM {
            let MIC_126: string;
            export { MIC_126 as MIC };
            let operatingMIC_126: string;
            export { operatingMIC_126 as operatingMIC };
        }
        namespace GU {
            let MIC_127: string;
            export { MIC_127 as MIC };
            let operatingMIC_127: string;
            export { operatingMIC_127 as operatingMIC };
        }
        namespace UC {
            let MIC_128: string;
            export { MIC_128 as MIC };
            let operatingMIC_128: string;
            export { operatingMIC_128 as operatingMIC };
        }
        namespace CF {
            let MIC_129: string;
            export { MIC_129 as MIC };
            let operatingMIC_129: string;
            export { operatingMIC_129 as operatingMIC };
        }
        namespace SL {
            let MIC_130: string;
            export { MIC_130 as MIC };
            let operatingMIC_130: string;
            export { operatingMIC_130 as operatingMIC };
        }
        namespace DC {
            let MIC_131: string;
            export { MIC_131 as MIC };
            let operatingMIC_131: string;
            export { operatingMIC_131 as operatingMIC };
        }
        namespace CY {
            let MIC_132: string;
            export { MIC_132 as MIC };
            let operatingMIC_132: string;
            export { operatingMIC_132 as operatingMIC };
        }
        namespace KH {
            let MIC_133: string;
            export { MIC_133 as MIC };
            let operatingMIC_133: string;
            export { operatingMIC_133 as operatingMIC };
        }
        namespace DS {
            let MIC_134: string;
            export { MIC_134 as MIC };
            let operatingMIC_134: string;
            export { operatingMIC_134 as operatingMIC };
        }
        namespace DK {
            let MIC_135: string;
            export { MIC_135 as MIC };
            let operatingMIC_135: string;
            export { operatingMIC_135 as operatingMIC };
        }
        namespace TZ {
            let MIC_136: string;
            export { MIC_136 as MIC };
            let operatingMIC_136: string;
            export { operatingMIC_136 as operatingMIC };
        }
        namespace IH {
            let MIC_137: string;
            export { MIC_137 as MIC };
            let operatingMIC_137: string;
            export { operatingMIC_137 as operatingMIC };
        }
        namespace DB {
            let MIC_138: string;
            export { MIC_138 as MIC };
            let operatingMIC_138: string;
            export { operatingMIC_138 as operatingMIC };
        }
        namespace BD {
            let MIC_139: string;
            export { MIC_139 as MIC };
            let operatingMIC_139: string;
            export { operatingMIC_139 as operatingMIC };
        }
        namespace SY {
            let MIC_140: string;
            export { MIC_140 as MIC };
            let operatingMIC_140: string;
            export { operatingMIC_140 as operatingMIC };
        }
        namespace DE {
            let MIC_141: string;
            export { MIC_141 as MIC };
            let operatingMIC_141: string;
            export { operatingMIC_141 as operatingMIC };
        }
        namespace ID {
            let MIC_142: string;
            export { MIC_142 as MIC };
            let operatingMIC_142: string;
            export { operatingMIC_142 as operatingMIC };
        }
        namespace GD {
            let MIC_143: string;
            export { MIC_143 as MIC };
            let operatingMIC_143: string;
            export { operatingMIC_143 as operatingMIC };
        }
        namespace YC {
            let MIC_144: string;
            export { MIC_144 as MIC };
            let operatingMIC_144: string;
            export { operatingMIC_144 as operatingMIC };
        }
        namespace EK {
            let MIC_145: string;
            export { MIC_145 as MIC };
            let operatingMIC_145: string;
            export { operatingMIC_145 as operatingMIC };
        }
        namespace BQ {
            let MIC_146: string;
            export { MIC_146 as MIC };
            let operatingMIC_146: string;
            export { operatingMIC_146 as operatingMIC };
        }
        namespace GY {
            let MIC_147: string;
            export { MIC_147 as MIC };
            let operatingMIC_147: string;
            export { operatingMIC_147 as operatingMIC };
        }
        namespace JF {
            let MIC_148: string;
            export { MIC_148 as MIC };
            let operatingMIC_148: string;
            export { operatingMIC_148 as operatingMIC };
        }
        namespace DF {
            let MIC_149: string;
            export { MIC_149 as MIC };
            let operatingMIC_149: string;
            export { operatingMIC_149 as operatingMIC };
        }
        namespace GF {
            let MIC_150: string;
            export { MIC_150 as MIC };
            let operatingMIC_150: string;
            export { operatingMIC_150 as operatingMIC };
        }
        namespace TH {
            let MIC_151: string;
            export { MIC_151 as MIC };
            let operatingMIC_151: string;
            export { operatingMIC_151 as operatingMIC };
        }
        namespace GN {
            let MIC_152: string;
            export { MIC_152 as MIC };
            let operatingMIC_152: string;
            export { operatingMIC_152 as operatingMIC };
        }
        namespace GG {
            let MIC_153: string;
            export { MIC_153 as MIC };
            let operatingMIC_153: string;
            export { operatingMIC_153 as operatingMIC };
        }
        namespace GL {
            let MIC_154: string;
            export { MIC_154 as MIC };
            let operatingMIC_154: string;
            export { operatingMIC_154 as operatingMIC };
        }
        namespace EG {
            let MIC_155: string;
            export { MIC_155 as MIC };
            let operatingMIC_155: string;
            export { operatingMIC_155 as operatingMIC };
        }
        namespace GH {
            let MIC_156: string;
            export { MIC_156 as MIC };
            let operatingMIC_156: string;
            export { operatingMIC_156 as operatingMIC };
        }
        namespace GI {
            let MIC_157: string;
            export { MIC_157 as MIC };
            let operatingMIC_157: string;
            export { operatingMIC_157 as operatingMIC };
        }
        namespace FH {
            let MIC_158: string;
            export { MIC_158 as MIC };
            let operatingMIC_158: string;
            export { operatingMIC_158 as operatingMIC };
        }
        namespace NR {
            let MIC_159: string;
            export { MIC_159 as MIC };
            let operatingMIC_159: string;
            export { operatingMIC_159 as operatingMIC };
        }
        namespace HK {
            let MIC_160: string;
            export { MIC_160 as MIC };
            let operatingMIC_160: string;
            export { operatingMIC_160 as operatingMIC };
        }
        namespace VU {
            let MIC_161: string;
            export { MIC_161 as MIC };
            let operatingMIC_161: string;
            export { operatingMIC_161 as operatingMIC };
        }
        namespace IR {
            let MIC_162: string;
            export { MIC_162 as MIC };
            let operatingMIC_162: string;
            export { operatingMIC_162 as operatingMIC };
        }
        namespace TW {
            let MIC_163: string;
            export { MIC_163 as MIC };
            let operatingMIC_163: string;
            export { operatingMIC_163 as operatingMIC };
        }
        namespace IJ {
            let MIC_164: string;
            export { MIC_164 as MIC };
            let operatingMIC_164: string;
            export { operatingMIC_164 as operatingMIC };
        }
        namespace IQ {
            let MIC_165: string;
            export { MIC_165 as MIC };
            let operatingMIC_165: string;
            export { operatingMIC_165 as operatingMIC };
        }
        namespace UL {
            let MIC_166: string;
            export { MIC_166 as MIC };
            let operatingMIC_166: string;
            export { operatingMIC_166 as operatingMIC };
        }
        namespace TI {
            let MIC_167: string;
            export { MIC_167 as MIC };
            let operatingMIC_167: string;
            export { operatingMIC_167 as operatingMIC };
        }
        namespace JA {
            let MIC_168: string;
            export { MIC_168 as MIC };
            let operatingMIC_168: string;
            export { operatingMIC_168 as operatingMIC };
        }
        namespace JQ {
            let MIC_169: string;
            export { MIC_169 as MIC };
            let operatingMIC_169: string;
            export { operatingMIC_169 as operatingMIC };
        }
        namespace SJ {
            let MIC_170: string;
            export { MIC_170 as MIC };
            let operatingMIC_170: string;
            export { operatingMIC_170 as operatingMIC };
        }
        namespace PK {
            let MIC_171: string;
            export { MIC_171 as MIC };
            let operatingMIC_171: string;
            export { operatingMIC_171 as operatingMIC };
        }
        namespace KZ {
            let MIC_172: string;
            export { MIC_172 as MIC };
            let operatingMIC_172: string;
            export { operatingMIC_172 as operatingMIC };
        }
        namespace KF {
            let MIC_173: string;
            export { MIC_173 as MIC };
            let operatingMIC_173: string;
            export { operatingMIC_173 as operatingMIC };
        }
        namespace MK {
            let MIC_174: string;
            export { MIC_174 as MIC };
            let operatingMIC_174: string;
            export { operatingMIC_174 as operatingMIC };
        }
        namespace KE {
            let MIC_175: string;
            export { MIC_175 as MIC };
            let operatingMIC_175: string;
            export { operatingMIC_175 as operatingMIC };
        }
        namespace KP {
            let MIC_176: string;
            export { MIC_176 as MIC };
            let operatingMIC_176: string;
            export { operatingMIC_176 as operatingMIC };
        }
        namespace KQ {
            let MIC_177: string;
            export { MIC_177 as MIC };
            let operatingMIC_177: string;
            export { operatingMIC_177 as operatingMIC };
        }
        namespace KB {
            let MIC_178: string;
            export { MIC_178 as MIC };
            let operatingMIC_178: string;
            export { operatingMIC_178 as operatingMIC };
        }
        namespace KK {
            let MIC_179: string;
            export { MIC_179 as MIC };
            let operatingMIC_179: string;
            export { operatingMIC_179 as operatingMIC };
        }
        namespace LS {
            let MIC_180: string;
            export { MIC_180 as MIC };
            let operatingMIC_180: string;
            export { operatingMIC_180 as operatingMIC };
        }
        namespace LD {
            let MIC_181: string;
            export { MIC_181 as MIC };
            let operatingMIC_181: string;
            export { operatingMIC_181 as operatingMIC };
        }
        namespace PE {
            let MIC_182: string;
            export { MIC_182 as MIC };
            let operatingMIC_182: string;
            export { operatingMIC_182 as operatingMIC };
        }
        namespace PL {
            let MIC_183: string;
            export { MIC_183 as MIC };
            let operatingMIC_183: string;
            export { operatingMIC_183 as operatingMIC };
        }
        namespace LH {
            let MIC_184: string;
            export { MIC_184 as MIC };
            let operatingMIC_184: string;
            export { operatingMIC_184 as operatingMIC };
        }
        namespace SV {
            let MIC_185: string;
            export { MIC_185 as MIC };
            let operatingMIC_185: string;
            export { operatingMIC_185 as operatingMIC };
        }
        namespace LN {
            let MIC_186: string;
            export { MIC_186 as MIC };
            let operatingMIC_186: string;
            export { operatingMIC_186 as operatingMIC };
        }
        namespace LY {
            let MIC_187: string;
            export { MIC_187 as MIC };
            let operatingMIC_187: string;
            export { operatingMIC_187 as operatingMIC };
        }
        namespace ZL {
            let MIC_188: string;
            export { MIC_188 as MIC };
            let operatingMIC_188: string;
            export { operatingMIC_188 as operatingMIC };
        }
        namespace LX {
            let MIC_189: string;
            export { MIC_189 as MIC };
            let operatingMIC_189: string;
            export { operatingMIC_189 as operatingMIC };
        }
        namespace SN {
            let MIC_190: string;
            export { MIC_190 as MIC };
            let operatingMIC_190: string;
            export { operatingMIC_190 as operatingMIC };
        }
        namespace MS {
            let MIC_191: string;
            export { MIC_191 as MIC };
            let operatingMIC_191: string;
            export { operatingMIC_191 as operatingMIC };
        }
        namespace MV {
            let MIC_192: string;
            export { MIC_192 as MIC };
            let operatingMIC_192: string;
            export { operatingMIC_192 as operatingMIC };
        }
        namespace NC {
            let MIC_193: string;
            export { MIC_193 as MIC };
            let operatingMIC_193: string;
            export { operatingMIC_193 as operatingMIC };
        }
        namespace MZ {
            let MIC_194: string;
            export { MIC_194 as MIC };
            let operatingMIC_194: string;
            export { operatingMIC_194 as operatingMIC };
        }
        namespace MP {
            let MIC_195: string;
            export { MIC_195 as MIC };
            let operatingMIC_195: string;
            export { operatingMIC_195 as operatingMIC };
        }
        namespace SQ {
            let MIC_196: string;
            export { MIC_196 as MIC };
            let operatingMIC_196: string;
            export { operatingMIC_196 as operatingMIC };
        }
        namespace MM {
            let MIC_197: string;
            export { MIC_197 as MIC };
            let operatingMIC_197: string;
            export { operatingMIC_197 as operatingMIC };
        }
        namespace UY {
            let MIC_198: string;
            export { MIC_198 as MIC };
            let operatingMIC_198: string;
            export { operatingMIC_198 as operatingMIC };
        }
        namespace ME {
            let MIC_199: string;
            export { MIC_199 as MIC };
            let operatingMIC_199: string;
            export { operatingMIC_199 as operatingMIC };
        }
        namespace MB {
            let MIC_200: string;
            export { MIC_200 as MIC };
            let operatingMIC_200: string;
            export { operatingMIC_200 as operatingMIC };
        }
        namespace MW {
            let MIC_201: string;
            export { MIC_201 as MIC };
            let operatingMIC_201: string;
            export { operatingMIC_201 as operatingMIC };
        }
        namespace GM {
            let MIC_202: string;
            export { MIC_202 as MIC };
            let operatingMIC_202: string;
            export { operatingMIC_202 as operatingMIC };
        }
        namespace OM {
            let MIC_203: string;
            export { MIC_203 as MIC };
            let operatingMIC_203: string;
            export { operatingMIC_203 as operatingMIC };
        }
        namespace KN {
            let MIC_204: string;
            export { MIC_204 as MIC };
            let operatingMIC_204: string;
            export { operatingMIC_204 as operatingMIC };
        }
        namespace NW {
            let MIC_205: string;
            export { MIC_205 as MIC };
            let operatingMIC_205: string;
            export { operatingMIC_205 as operatingMIC };
        }
        namespace UR {
            let MIC_206: string;
            export { MIC_206 as MIC };
            let operatingMIC_206: string;
            export { operatingMIC_206 as operatingMIC };
        }
        namespace AO {
            let MIC_207: string;
            export { MIC_207 as MIC };
            let operatingMIC_207: string;
            export { operatingMIC_207 as operatingMIC };
        }
        namespace NK {
            let MIC_208: string;
            export { MIC_208 as MIC };
            let operatingMIC_208: string;
            export { operatingMIC_208 as operatingMIC };
        }
        namespace EX {
            let MIC_209: string;
            export { MIC_209 as MIC };
            let operatingMIC_209: string;
            export { operatingMIC_209 as operatingMIC };
        }
        namespace NG {
            let MIC_210: string;
            export { MIC_210 as MIC };
            let operatingMIC_210: string;
            export { operatingMIC_210 as operatingMIC };
        }
        namespace JN {
            let MIC_211: string;
            export { MIC_211 as MIC };
            let operatingMIC_211: string;
            export { operatingMIC_211 as operatingMIC };
        }
        namespace UW {
            let MIC_212: string;
            export { MIC_212 as MIC };
            let operatingMIC_212: string;
            export { operatingMIC_212 as operatingMIC };
        }
        namespace UT {
            let MIC_213: string;
            export { MIC_213 as MIC };
            let operatingMIC_213: string;
            export { operatingMIC_213 as operatingMIC };
        }
        namespace UQ {
            let MIC_214: string;
            export { MIC_214 as MIC };
            let operatingMIC_214: string;
            export { operatingMIC_214 as operatingMIC };
        }
        namespace NL {
            let MIC_215: string;
            export { MIC_215 as MIC };
            let operatingMIC_215: string;
            export { operatingMIC_215 as operatingMIC };
        }
        namespace IS {
            let MIC_216: string;
            export { MIC_216 as MIC };
            let operatingMIC_216: string;
            export { operatingMIC_216 as operatingMIC };
        }
        namespace UN {
            let MIC_217: string;
            export { MIC_217 as MIC };
            let operatingMIC_217: string;
            export { operatingMIC_217 as operatingMIC };
        }
        namespace NZ {
            let MIC_218: string;
            export { MIC_218 as MIC };
            let operatingMIC_218: string;
            export { operatingMIC_218 as operatingMIC };
        }
        namespace JO {
            let MIC_219: string;
            export { MIC_219 as MIC };
            let operatingMIC_219: string;
            export { operatingMIC_219 as operatingMIC };
        }
        namespace NO {
            let MIC_220: string;
            export { MIC_220 as MIC };
            let operatingMIC_220: string;
            export { operatingMIC_220 as operatingMIC };
        }
        namespace UU {
            let MIC_221: string;
            export { MIC_221 as MIC };
            let operatingMIC_221: string;
            export { operatingMIC_221 as operatingMIC };
        }
        namespace XO {
            let MIC_222: string;
            export { MIC_222 as MIC };
            let operatingMIC_222: string;
            export { operatingMIC_222 as operatingMIC };
        }
        namespace PS {
            let MIC_223: string;
            export { MIC_223 as MIC };
            let operatingMIC_223: string;
            export { operatingMIC_223 as operatingMIC };
        }
        namespace FP {
            let MIC_224: string;
            export { MIC_224 as MIC };
            let operatingMIC_224: string;
            export { operatingMIC_224 as operatingMIC };
        }
        namespace UX {
            let MIC_225: string;
            export { MIC_225 as MIC };
            let operatingMIC_225: string;
            export { operatingMIC_225 as operatingMIC };
        }
        namespace PM {
            let MIC_226: string;
            export { MIC_226 as MIC };
            let operatingMIC_226: string;
            export { operatingMIC_226 as operatingMIC };
        }
        namespace PZ {
            let MIC_227: string;
            export { MIC_227 as MIC };
            let operatingMIC_227: string;
            export { operatingMIC_227 as operatingMIC };
        }
        namespace PB {
            let MIC_228: string;
            export { MIC_228 as MIC };
            let operatingMIC_228: string;
            export { operatingMIC_228 as operatingMIC };
        }
        namespace PO {
            let MIC_229: string;
            export { MIC_229 as MIC };
            let operatingMIC_229: string;
            export { operatingMIC_229 as operatingMIC };
        }
        namespace PP {
            let MIC_230: string;
            export { MIC_230 as MIC };
            let operatingMIC_230: string;
            export { operatingMIC_230 as operatingMIC };
        }
        namespace SX {
            let MIC_231: string;
            export { MIC_231 as MIC };
            let operatingMIC_231: string;
            export { operatingMIC_231 as operatingMIC };
        }
        namespace QT {
            let MIC_232: string;
            export { MIC_232 as MIC };
            let operatingMIC_232: string;
            export { operatingMIC_232 as operatingMIC };
        }
        namespace EQ {
            let MIC_233: string;
            export { MIC_233 as MIC };
            let operatingMIC_233: string;
            export { operatingMIC_233 as operatingMIC };
        }
        namespace RQ {
            let MIC_234: string;
            export { MIC_234 as MIC };
            let operatingMIC_234: string;
            export { operatingMIC_234 as operatingMIC };
        }
        namespace LG {
            let MIC_235: string;
            export { MIC_235 as MIC };
            let operatingMIC_235: string;
            export { operatingMIC_235 as operatingMIC };
        }
        namespace RC {
            let MIC_236: string;
            export { MIC_236 as MIC };
            let operatingMIC_236: string;
            export { operatingMIC_236 as operatingMIC };
        }
        namespace JS {
            let MIC_237: string;
            export { MIC_237 as MIC };
            let operatingMIC_237: string;
            export { operatingMIC_237 as operatingMIC };
        }
        namespace KA {
            let MIC_238: string;
            export { MIC_238 as MIC };
            let operatingMIC_238: string;
            export { operatingMIC_238 as operatingMIC };
        }
        namespace AB {
            let MIC_239: string;
            export { MIC_239 as MIC };
            let operatingMIC_239: string;
            export { operatingMIC_239 as operatingMIC };
        }
        namespace JU {
            let MIC_240: string;
            export { MIC_240 as MIC };
            let operatingMIC_240: string;
            export { operatingMIC_240 as operatingMIC };
        }
        namespace C2 {
            let MIC_241: string;
            export { MIC_241 as MIC };
            let operatingMIC_241: string;
            export { operatingMIC_241 as operatingMIC };
        }
        namespace SP {
            let MIC_242: string;
            export { MIC_242 as MIC };
            let operatingMIC_242: string;
            export { operatingMIC_242 as operatingMIC };
        }
        namespace CC {
            let MIC_243: string;
            export { MIC_243 as MIC };
            let operatingMIC_243: string;
            export { operatingMIC_243 as operatingMIC };
        }
        namespace CS {
            let MIC_244: string;
            export { MIC_244 as MIC };
            let operatingMIC_244: string;
            export { operatingMIC_244 as operatingMIC };
        }
        namespace CG {
            let MIC_245: string;
            export { MIC_245 as MIC };
            let operatingMIC_245: string;
            export { operatingMIC_245 as operatingMIC };
        }
        namespace XE {
            let MIC_246: string;
            export { MIC_246 as MIC };
            let operatingMIC_246: string;
            export { operatingMIC_246 as operatingMIC };
        }
        namespace FS {
            let MIC_247: string;
            export { MIC_247 as MIC };
            let operatingMIC_247: string;
            export { operatingMIC_247 as operatingMIC };
        }
        namespace C1 {
            let MIC_248: string;
            export { MIC_248 as MIC };
            let operatingMIC_248: string;
            export { operatingMIC_248 as operatingMIC };
        }
        namespace BT {
            let MIC_249: string;
            export { MIC_249 as MIC };
            let operatingMIC_249: string;
            export { operatingMIC_249 as operatingMIC };
        }
        namespace VM {
            let MIC_250: string;
            export { MIC_250 as MIC };
            let operatingMIC_250: string;
            export { operatingMIC_250 as operatingMIC };
        }
        namespace ZU {
            let MIC_251: string;
            export { MIC_251 as MIC };
            let operatingMIC_251: string;
            export { operatingMIC_251 as operatingMIC };
        }
        namespace SS {
            let MIC_252: string;
            export { MIC_252 as MIC };
            let operatingMIC_252: string;
            export { operatingMIC_252 as operatingMIC };
        }
        namespace GS {
            let MIC_253: string;
            export { MIC_253 as MIC };
            let operatingMIC_253: string;
            export { operatingMIC_253 as operatingMIC };
        }
        namespace EL {
            let MIC_254: string;
            export { MIC_254 as MIC };
            let operatingMIC_254: string;
            export { operatingMIC_254 as operatingMIC };
        }
        namespace SD {
            let MIC_255: string;
            export { MIC_255 as MIC };
            let operatingMIC_255: string;
            export { operatingMIC_255 as operatingMIC };
        }
        namespace SE {
            let MIC_256: string;
            export { MIC_256 as MIC };
            let operatingMIC_256: string;
            export { operatingMIC_256 as operatingMIC };
        }
        namespace IT {
            let MIC_257: string;
            export { MIC_257 as MIC };
            let operatingMIC_257: string;
            export { operatingMIC_257 as operatingMIC };
        }
        namespace ET {
            let MIC_258: string;
            export { MIC_258 as MIC };
            let operatingMIC_258: string;
            export { operatingMIC_258 as operatingMIC };
        }
        namespace JG {
            let MIC_259: string;
            export { MIC_259 as MIC };
            let operatingMIC_259: string;
            export { operatingMIC_259 as operatingMIC };
        }
        namespace IE {
            let MIC_260: string;
            export { MIC_260 as MIC };
            let operatingMIC_260: string;
            export { operatingMIC_260 as operatingMIC };
        }
        namespace AL {
            let MIC_261: string;
            export { MIC_261 as MIC };
            let operatingMIC_261: string;
            export { operatingMIC_261 as operatingMIC };
        }
        namespace JT {
            let MIC_262: string;
            export { MIC_262 as MIC };
            let operatingMIC_262: string;
            export { operatingMIC_262 as operatingMIC };
        }
        namespace TP {
            let MIC_263: string;
            export { MIC_263 as MIC };
            let operatingMIC_263: string;
            export { operatingMIC_263 as operatingMIC };
        }
        namespace CT {
            let MIC_264: string;
            export { MIC_264 as MIC };
            let operatingMIC_264: string;
            export { operatingMIC_264 as operatingMIC };
        }
        namespace CV {
            let MIC_265: string;
            export { MIC_265 as MIC };
            let operatingMIC_265: string;
            export { operatingMIC_265 as operatingMIC };
        }
        namespace TU {
            let MIC_266: string;
            export { MIC_266 as MIC };
            let operatingMIC_266: string;
            export { operatingMIC_266 as operatingMIC };
        }
        namespace UK {
            let MIC_267: string;
            export { MIC_267 as MIC };
            let operatingMIC_267: string;
            export { operatingMIC_267 as operatingMIC };
        }
        namespace S2 {
            let MIC_268: string;
            export { MIC_268 as MIC };
            let operatingMIC_268: string;
            export { operatingMIC_268 as operatingMIC };
        }
        namespace UG {
            let MIC_269: string;
            export { MIC_269 as MIC };
            let operatingMIC_269: string;
            export { operatingMIC_269 as operatingMIC };
        }
        namespace MO {
            let MIC_270: string;
            export { MIC_270 as MIC };
            let operatingMIC_270: string;
            export { operatingMIC_270 as operatingMIC };
        }
        namespace SA {
            let MIC_271: string;
            export { MIC_271 as MIC };
            let operatingMIC_271: string;
            export { operatingMIC_271 as operatingMIC };
        }
        namespace PN {
            let MIC_272: string;
            export { MIC_272 as MIC };
            let operatingMIC_272: string;
            export { operatingMIC_272 as operatingMIC };
        }
        namespace VX {
            let MIC_273: string;
            export { MIC_273 as MIC };
            let operatingMIC_273: string;
            export { operatingMIC_273 as operatingMIC };
        }
        namespace PW {
            let MIC_274: string;
            export { MIC_274 as MIC };
            let operatingMIC_274: string;
            export { operatingMIC_274 as operatingMIC };
        }
        namespace AV {
            let MIC_275: string;
            export { MIC_275 as MIC };
            let operatingMIC_275: string;
            export { operatingMIC_275 as operatingMIC };
        }
        namespace ZA {
            let MIC_276: string;
            export { MIC_276 as MIC };
            let operatingMIC_276: string;
            export { operatingMIC_276 as operatingMIC };
        }
        namespace ZH {
            let MIC_277: string;
            export { MIC_277 as MIC };
            let operatingMIC_277: string;
            export { operatingMIC_277 as operatingMIC };
        }
    }
    export namespace MIC_278 {
        let APXL: string;
        let ARCX: string;
        let ASXP: string;
        let AQXE: string;
        let BATE: string;
        let BATS: string;
        let BATY: string;
        let BCSE: string;
        let BOAT: string;
        let BLNK: string;
        let BLOX: string;
        let BMFX: string;
        let BOTC: string;
        let BSEX: string;
        let BURG: string;
        let CBSX: string;
        let CHIA: string;
        let CHIJ: string;
        let CHIX: string;
        let CHIC: string;
        let DKTC: string;
        let DIFX: string;
        let DSMD: string;
        let EDGA: string;
        let EDGX: string;
        let ENAX: string;
        let ETLX: string;
        let EUWX: string;
        let XBRN: string;
        let FNFI: string;
        let FNSE: string;
        let GSXL: string;
        let HMTF: string;
        let HOTC: string;
        let HSTC: string;
        let ICEL: string;
        let IEXG: string;
        let FNIS: string;
        let KABU: string;
        let LICA: string;
        let LIQU: string;
        let LYNX: string;
        let MALX: string;
        let MATN: string;
        let MCXX: string;
        let MESQ: string;
        let MISX: string;
        let MTAA: string;
        let MTAH: string;
        let WMTF: string;
        let MUNB: string;
        let NEOE: string;
        let NILX: string;
        let NOTC: string;
        let NURD: string;
        let NURO: string;
        let OMGA: string;
        let OOTC: string;
        let OPEX: string;
        let PFTS: string;
        let PFTQ: string;
        let OTCM: string;
        let PURE: string;
        let QMTF: string;
        let ROCO: string;
        let ROTC: string;
        let RTSX: string;
        let RUSX: string;
        let SBIJ: string;
        let SBIU: string;
        let SHSC: string;
        let SGMX: string;
        let SIGX: string;
        let SHAR: string;
        let SIMV: string;
        let SZSC: string;
        let TMXS: string;
        let TOMX: string;
        let TRPX: string;
        let TRQD: string;
        let TRQX: string;
        let XATS: string;
        let XADE: string;
        let XADF: string;
        let XADS: string;
        let XALG: string;
        let XAMM: string;
        let XAMS: string;
        let XARM: string;
        let XASE: string;
        let XASX: string;
        let XATH: string;
        let XBAA: string;
        let XBAB: string;
        let XBAH: string;
        let XBAR: string;
        let XBCL: string;
        let XBCX: string;
        let XBCV: string;
        let XBDA: string;
        let XBEL: string;
        let XBER: string;
        let XBEY: string;
        let XBIL: string;
        let XBKK: string;
        let XBLB: string;
        let XBNV: string;
        let XBOG: string;
        let XBOL: string;
        let XBOM: string;
        let XBOS: string;
        let XBOT: string;
        let XBRA: string;
        let XBRU: string;
        let XBRV: string;
        let XBSE: string;
        let XBUD: string;
        let XBUE: string;
        let XBUL: string;
        let XBVC: string;
        let XCAI: string;
        let BVCA: string;
        let XCAS: string;
        let XCAY: string;
        let XCHI: string;
        let XCIE: string;
        let XCIS: string;
        let XCNQ: string;
        let XCOL: string;
        let XCSE: string;
        let XCYS: string;
        let XCSX: string;
        let XCX2: string;
        let XCXD: string;
        let XDAR: string;
        let XDES: string;
        let XDFM: string;
        let XDHA: string;
        let XDSE: string;
        let XDSX: string;
        let XDUB: string;
        let XDUS: string;
        let XECM: string;
        let XECS: string;
        let XEQT: string;
        let XETR: string;
        let XFKA: string;
        let FNDK: string;
        let XFRA: string;
        let XGAT: string;
        let XGHA: string;
        let XGSE: string;
        let XGTG: string;
        let XGUA: string;
        let XHAM: string;
        let XHAN: string;
        let XHEL: string;
        let XHFT: string;
        let XHKG: string;
        let XHNX: string;
        let XICE: string;
        let XICX: string;
        let XIDX: string;
        let XIQS: string;
        let XISE: string;
        let XIST: string;
        let XJAM: string;
        let XJAS: string;
        let XJSE: string;
        let XKAR: string;
        let XKAZ: string;
        let XKFB: string;
        let XKLS: string;
        let XKON: string;
        let XKRX: string;
        let XKOS: string;
        let XKSE: string;
        let XKUW: string;
        let XLAO: string;
        let XLDN: string;
        let XLIM: string;
        let XLIS: string;
        let XLIT: string;
        let XLJU: string;
        let XLON: string;
        let XLSM: string;
        let XLUS: string;
        let XLUX: string;
        let XMAD: string;
        let XMAE: string;
        let XMAL: string;
        let XMAN: string;
        let XBVM: string;
        let XMAU: string;
        let XMCE: string;
        let XMEX: string;
        let XMNT: string;
        let XMNX: string;
        let XMOL: string;
        let XMSW: string;
        let XMUN: string;
        let XMUS: string;
        let XNAI: string;
        let XNAM: string;
        let XNCM: string;
        let XNEC: string;
        let XNEP: string;
        let XNEW: string;
        let XNGM: string;
        let XNGO: string;
        let XNGS: string;
        let XNIM: string;
        let XNMS: string;
        let XNSA: string;
        let XNSE: string;
        let XNYS: string;
        let XNZE: string;
        let XOSE: string;
        let XOSL: string;
        let XOTC: string;
        let XOPV: string;
        let XPAE: string;
        let XPAR: string;
        let XPSX: string;
        let XPHS: string;
        let ISDX: string;
        let XPOM: string;
        let XPOS: string;
        let XPTY: string;
        let XQMH: string;
        let XQTX: string;
        let XQUI: string;
        let XRAS: string;
        let XRIS: string;
        let XRMZ: string;
        let XSAP: string;
        let XSAT: string;
        let XSAU: string;
        let XSBI: string;
        let XSEC: string;
        let XSES: string;
        let XSGO: string;
        let XSHE: string;
        let XSHG: string;
        let XSMP: string;
        let XSPS: string;
        let XSSC: string;
        let XSSE: string;
        let XSTC: string;
        let XSTE: string;
        let XSTO: string;
        let XSTU: string;
        let XSVA: string;
        let XSWA: string;
        let XSWX: string;
        let XTAE: string;
        let XTAI: string;
        let XTAL: string;
        let XTAM: string;
        let XTEH: string;
        let XTIR: string;
        let XTKS: string;
        let XTRN: string;
        let XTSE: string;
        let XTSX: string;
        let XTUN: string;
        let UKEX: string;
        let XUBS: string;
        let XUGA: string;
        let XULA: string;
        let XVAL: string;
        let XVPA: string;
        let XVTX: string;
        let XWAR: string;
        let XWBO: string;
        let XZAG: string;
        let XZIM: string;
    }
    export { MIC_278 as MIC };
    export namespace operatingMIC_278 {
        let APXL_1: string;
        export { APXL_1 as APXL };
        let XNYS_1: string;
        export { XNYS_1 as XNYS };
        let XASX_1: string;
        export { XASX_1 as XASX };
        let AQXE_1: string;
        export { AQXE_1 as AQXE };
        export let BCXE: string;
        let BATS_1: string;
        export { BATS_1 as BATS };
        let BCSE_1: string;
        export { BCSE_1 as BCSE };
        let BOAT_1: string;
        export { BOAT_1 as BOAT };
        export let CHEV: string;
        let BLOX_1: string;
        export { BLOX_1 as BLOX };
        let BMFX_1: string;
        export { BMFX_1 as BMFX };
        let BSEX_1: string;
        export { BSEX_1 as BSEX };
        let XOSL_1: string;
        export { XOSL_1 as XOSL };
        export let XCBO: string;
        let CHIA_1: string;
        export { CHIA_1 as CHIA };
        let CHIJ_1: string;
        export { CHIJ_1 as CHIJ };
        let CHIC_1: string;
        export { CHIC_1 as CHIC };
        let DKTC_1: string;
        export { DKTC_1 as DKTC };
        let DIFX_1: string;
        export { DIFX_1 as DIFX };
        let DSMD_1: string;
        export { DSMD_1 as DSMD };
        export let EDGE: string;
        export let ASEX: string;
        let ETLX_1: string;
        export { ETLX_1 as ETLX };
        let XSTU_1: string;
        export { XSTU_1 as XSTU };
        let XBRN_1: string;
        export { XBRN_1 as XBRN };
        let XHEL_1: string;
        export { XHEL_1 as XHEL };
        let XSTO_1: string;
        export { XSTO_1 as XSTO };
        let GSXL_1: string;
        export { GSXL_1 as GSXL };
        let HMTF_1: string;
        export { HMTF_1 as HMTF };
        let HSTC_1: string;
        export { HSTC_1 as HSTC };
        let ICEL_1: string;
        export { ICEL_1 as ICEL };
        let IEXG_1: string;
        export { IEXG_1 as IEXG };
        let XICE_1: string;
        export { XICE_1 as XICE };
        let KABU_1: string;
        export { KABU_1 as KABU };
        let LICA_1: string;
        export { LICA_1 as LICA };
        let LIQU_1: string;
        export { LIQU_1 as LIQU };
        let OMGA_1: string;
        export { OMGA_1 as OMGA };
        let MALX_1: string;
        export { MALX_1 as MALX };
        let MATN_1: string;
        export { MATN_1 as MATN };
        let MCXX_1: string;
        export { MCXX_1 as MCXX };
        let XKLS_1: string;
        export { XKLS_1 as XKLS };
        let MISX_1: string;
        export { MISX_1 as MISX };
        export let XMIL: string;
        let XWAR_1: string;
        export { XWAR_1 as XWAR };
        export let PLUS: string;
        let NEOE_1: string;
        export { NEOE_1 as NEOE };
        let NILX_1: string;
        export { NILX_1 as NILX };
        let NOTC_1: string;
        export { NOTC_1 as NOTC };
        let NURO_1: string;
        export { NURO_1 as NURO };
        export let FINR: string;
        let OPEX_1: string;
        export { OPEX_1 as OPEX };
        let PFTS_1: string;
        export { PFTS_1 as PFTS };
        let OTCM_1: string;
        export { OTCM_1 as OTCM };
        let XCNQ_1: string;
        export { XCNQ_1 as XCNQ };
        let QMTF_1: string;
        export { QMTF_1 as QMTF };
        let ROCO_1: string;
        export { ROCO_1 as ROCO };
        let ROTC_1: string;
        export { ROTC_1 as ROTC };
        let RUSX_1: string;
        export { RUSX_1 as RUSX };
        let SBIJ_1: string;
        export { SBIJ_1 as SBIJ };
        let XHKG_1: string;
        export { XHKG_1 as XHKG };
        let SGMX_1: string;
        export { SGMX_1 as SGMX };
        let SIGX_1: string;
        export { SIGX_1 as SIGX };
        let SHAR_1: string;
        export { SHAR_1 as SHAR };
        let SIMV_1: string;
        export { SIMV_1 as SIMV };
        let TMXS_1: string;
        export { TMXS_1 as TMXS };
        let TOMX_1: string;
        export { TOMX_1 as TOMX };
        let TRPX_1: string;
        export { TRPX_1 as TRPX };
        let TRQX_1: string;
        export { TRQX_1 as TRQX };
        let XATS_1: string;
        export { XATS_1 as XATS };
        let XADS_1: string;
        export { XADS_1 as XADS };
        let XALG_1: string;
        export { XALG_1 as XALG };
        let XAMM_1: string;
        export { XAMM_1 as XAMM };
        let XAMS_1: string;
        export { XAMS_1 as XAMS };
        let XARM_1: string;
        export { XARM_1 as XARM };
        let XBAA_1: string;
        export { XBAA_1 as XBAA };
        let XBAB_1: string;
        export { XBAB_1 as XBAB };
        let XBAH_1: string;
        export { XBAH_1 as XBAH };
        export let BMEX: string;
        let XBCL_1: string;
        export { XBCL_1 as XBCL };
        export let XBCM: string;
        let XBCV_1: string;
        export { XBCV_1 as XBCV };
        let XBDA_1: string;
        export { XBDA_1 as XBDA };
        let XBEL_1: string;
        export { XBEL_1 as XBEL };
        let XBER_1: string;
        export { XBER_1 as XBER };
        let XBEY_1: string;
        export { XBEY_1 as XBEY };
        let XBKK_1: string;
        export { XBKK_1 as XBKK };
        let XBLB_1: string;
        export { XBLB_1 as XBLB };
        let XBNV_1: string;
        export { XBNV_1 as XBNV };
        let XBOG_1: string;
        export { XBOG_1 as XBOG };
        let XBOL_1: string;
        export { XBOL_1 as XBOL };
        let XBOM_1: string;
        export { XBOM_1 as XBOM };
        export let XNAS: string;
        let XBOT_1: string;
        export { XBOT_1 as XBOT };
        let XBRA_1: string;
        export { XBRA_1 as XBRA };
        let XBRU_1: string;
        export { XBRU_1 as XBRU };
        let XBRV_1: string;
        export { XBRV_1 as XBRV };
        let XBSE_1: string;
        export { XBSE_1 as XBSE };
        let XBUD_1: string;
        export { XBUD_1 as XBUD };
        let XBUE_1: string;
        export { XBUE_1 as XBUE };
        let XBUL_1: string;
        export { XBUL_1 as XBUL };
        let XBVC_1: string;
        export { XBVC_1 as XBVC };
        let XCAI_1: string;
        export { XCAI_1 as XCAI };
        let BVCA_1: string;
        export { BVCA_1 as BVCA };
        let XCAS_1: string;
        export { XCAS_1 as XCAS };
        let XCAY_1: string;
        export { XCAY_1 as XCAY };
        let XCHI_1: string;
        export { XCHI_1 as XCHI };
        let XCIE_1: string;
        export { XCIE_1 as XCIE };
        let XCIS_1: string;
        export { XCIS_1 as XCIS };
        let XCOL_1: string;
        export { XCOL_1 as XCOL };
        let XCSE_1: string;
        export { XCSE_1 as XCSE };
        let XCYS_1: string;
        export { XCYS_1 as XCYS };
        let XCSX_1: string;
        export { XCSX_1 as XCSX };
        let XCXD_1: string;
        export { XCXD_1 as XCXD };
        let XDAR_1: string;
        export { XDAR_1 as XDAR };
        let XDES_1: string;
        export { XDES_1 as XDES };
        let XDFM_1: string;
        export { XDFM_1 as XDFM };
        let XDHA_1: string;
        export { XDHA_1 as XDHA };
        let XDSE_1: string;
        export { XDSE_1 as XDSE };
        let XDSX_1: string;
        export { XDSX_1 as XDSX };
        let XDUB_1: string;
        export { XDUB_1 as XDUB };
        let XDUS_1: string;
        export { XDUS_1 as XDUS };
        let XECS_1: string;
        export { XECS_1 as XECS };
        let XFRA_1: string;
        export { XFRA_1 as XFRA };
        let XFKA_1: string;
        export { XFKA_1 as XFKA };
        export let TGAT: string;
        let XGHA_1: string;
        export { XGHA_1 as XGHA };
        let XGSE_1: string;
        export { XGSE_1 as XGSE };
        let XGTG_1: string;
        export { XGTG_1 as XGTG };
        let XGUA_1: string;
        export { XGUA_1 as XGUA };
        let XHAM_1: string;
        export { XHAM_1 as XHAM };
        let XHAN_1: string;
        export { XHAN_1 as XHAN };
        let XHFT_1: string;
        export { XHFT_1 as XHFT };
        let XICX_1: string;
        export { XICX_1 as XICX };
        let XIDX_1: string;
        export { XIDX_1 as XIDX };
        let XIQS_1: string;
        export { XIQS_1 as XIQS };
        export let XISX: string;
        let XIST_1: string;
        export { XIST_1 as XIST };
        let XJAM_1: string;
        export { XJAM_1 as XJAM };
        export let XJPX: string;
        let XJSE_1: string;
        export { XJSE_1 as XJSE };
        let XKAR_1: string;
        export { XKAR_1 as XKAR };
        let XKAZ_1: string;
        export { XKAZ_1 as XKAZ };
        let XKFB_1: string;
        export { XKFB_1 as XKFB };
        let XKRX_1: string;
        export { XKRX_1 as XKRX };
        let XKSE_1: string;
        export { XKSE_1 as XKSE };
        let XKUW_1: string;
        export { XKUW_1 as XKUW };
        let XLAO_1: string;
        export { XLAO_1 as XLAO };
        let XLDN_1: string;
        export { XLDN_1 as XLDN };
        let XLIM_1: string;
        export { XLIM_1 as XLIM };
        let XLIS_1: string;
        export { XLIS_1 as XLIS };
        let XLIT_1: string;
        export { XLIT_1 as XLIT };
        let XLJU_1: string;
        export { XLJU_1 as XLJU };
        let XLON_1: string;
        export { XLON_1 as XLON };
        let XLSM_1: string;
        export { XLSM_1 as XLSM };
        let XLUS_1: string;
        export { XLUS_1 as XLUS };
        let XLUX_1: string;
        export { XLUX_1 as XLUX };
        let XMAE_1: string;
        export { XMAE_1 as XMAE };
        let XMAL_1: string;
        export { XMAL_1 as XMAL };
        let XMAN_1: string;
        export { XMAN_1 as XMAN };
        let XBVM_1: string;
        export { XBVM_1 as XBVM };
        let XMAU_1: string;
        export { XMAU_1 as XMAU };
        let XMEX_1: string;
        export { XMEX_1 as XMEX };
        let XMNT_1: string;
        export { XMNT_1 as XMNT };
        let XMNX_1: string;
        export { XMNX_1 as XMNX };
        let XMOL_1: string;
        export { XMOL_1 as XMOL };
        let XMSW_1: string;
        export { XMSW_1 as XMSW };
        let XMUN_1: string;
        export { XMUN_1 as XMUN };
        let XMUS_1: string;
        export { XMUS_1 as XMUS };
        let XNAI_1: string;
        export { XNAI_1 as XNAI };
        let XNAM_1: string;
        export { XNAM_1 as XNAM };
        let XNEC_1: string;
        export { XNEC_1 as XNEC };
        let XNEP_1: string;
        export { XNEP_1 as XNEP };
        let XNGM_1: string;
        export { XNGM_1 as XNGM };
        let XNGO_1: string;
        export { XNGO_1 as XNGO };
        let XNSA_1: string;
        export { XNSA_1 as XNSA };
        let XNSE_1: string;
        export { XNSE_1 as XNSE };
        let XNZE_1: string;
        export { XNZE_1 as XNZE };
        let XOTC_1: string;
        export { XOTC_1 as XOTC };
        let XPAE_1: string;
        export { XPAE_1 as XPAE };
        let XPAR_1: string;
        export { XPAR_1 as XPAR };
        let XPHS_1: string;
        export { XPHS_1 as XPHS };
        export let ICAP: string;
        let XPOM_1: string;
        export { XPOM_1 as XPOM };
        export let ITGI: string;
        let XPTY_1: string;
        export { XPTY_1 as XPTY };
        let XQMH_1: string;
        export { XQMH_1 as XQMH };
        let XQUI_1: string;
        export { XQUI_1 as XQUI };
        let XRIS_1: string;
        export { XRIS_1 as XRIS };
        let XRMZ_1: string;
        export { XRMZ_1 as XRMZ };
        let XSAP_1: string;
        export { XSAP_1 as XSAP };
        let XSAT_1: string;
        export { XSAT_1 as XSAT };
        let XSAU_1: string;
        export { XSAU_1 as XSAU };
        let XSHE_1: string;
        export { XSHE_1 as XSHE };
        let XSES_1: string;
        export { XSES_1 as XSES };
        let XSGO_1: string;
        export { XSGO_1 as XSGO };
        let XSHG_1: string;
        export { XSHG_1 as XSHG };
        let XSMP_1: string;
        export { XSMP_1 as XSMP };
        let XSPS_1: string;
        export { XSPS_1 as XSPS };
        let XSSE_1: string;
        export { XSSE_1 as XSSE };
        let XSTC_1: string;
        export { XSTC_1 as XSTC };
        let XSTE_1: string;
        export { XSTE_1 as XSTE };
        let XSVA_1: string;
        export { XSVA_1 as XSVA };
        let XSWA_1: string;
        export { XSWA_1 as XSWA };
        let XSWX_1: string;
        export { XSWX_1 as XSWX };
        let XTAE_1: string;
        export { XTAE_1 as XTAE };
        let XTAI_1: string;
        export { XTAI_1 as XTAI };
        let XTAL_1: string;
        export { XTAL_1 as XTAL };
        let XTEH_1: string;
        export { XTEH_1 as XTEH };
        let XTIR_1: string;
        export { XTIR_1 as XTIR };
        let XTKS_1: string;
        export { XTKS_1 as XTKS };
        let XTRN_1: string;
        export { XTRN_1 as XTRN };
        let XTSE_1: string;
        export { XTSE_1 as XTSE };
        let XTSX_1: string;
        export { XTSX_1 as XTSX };
        let XTUN_1: string;
        export { XTUN_1 as XTUN };
        let UKEX_1: string;
        export { UKEX_1 as UKEX };
        let XUBS_1: string;
        export { XUBS_1 as XUBS };
        let XUGA_1: string;
        export { XUGA_1 as XUGA };
        let XULA_1: string;
        export { XULA_1 as XULA };
        let XVPA_1: string;
        export { XVPA_1 as XVPA };
        let XWBO_1: string;
        export { XWBO_1 as XWBO };
        let XZAG_1: string;
        export { XZAG_1 as XZAG };
        let XZIM_1: string;
        export { XZIM_1 as XZIM };
    }
    export { operatingMIC_278 as operatingMIC };
}
export default _default;
//# sourceMappingURL=mic_map.d.ts.map