igc.py

import sys
import struct
import re
import string
import math
import os
import errno

ET_NAMES = [ "chaff", "weapon", "magazine", "dispenser", "shield", "cloak", "pack", "booster" ]
ET_CHAFF = 0
ET_WEAPON = 1
ET_MAGAZINE = 2
ET_DISPENSER = 3
ET_SHIELD = 4
ET_CLOAK = 5
ET_PACK = 6
ET_BOOSTER = 7
ET_MAX = 8

OT_PROTECTILETYPE = 22
OT_MISSILETYPE = 23
OT_MINETYPE = 24
OT_PROBETYPE = 25
OT_CHAFFTYPE = 26
OT_FACTION = 27
OT_TREASURESET = 28
OT_HULLTYPE = 29
OT_PARTTYPE = 30
OT_STATIONTYPE = 31
OT_TECH = 32
OT_DRONETYPE = 33
OT_CONSTANTS = 34

def getString( data ):
    return data[ 0 : data.find( chr(0) ) ]
    copy = ""
    for c in data:
        if c == chr(0):
            copy += "+"
        else:
            copy += c
    return copy

def getType(data):
    if data >= len( ET_NAMES ) or data < 0:
        return "RANGE!!"
    return ET_NAMES[ data ]

def getStationClass( data ):
    classes = [ "Starbase" , "Garrison" , "Shipyard", "Ripcord", "Mining", "Research", "Ordinance", "Electronics" ]
    if data >= len( classes ) or data < 0:
        return "RANGE!!"

    return classes[ data ]

def getPilotType( data ):
    types = [ "Miner", "Wingman", "Layer", "Builder", "Carrier", "Player", "CheatPlayer" ]
    if data >= len( types ) or data < 0:
        return "RANGE!!"
    
    return types[ data ]

def getHullAttribs( data ):
    abilities = [ "Board", "Rescue", "Lifepod", "Warn Capture", "Dock Carrier", "No Rip", "Is Rip", "Fighter", "Relay Lead", "Warn Station", "Carrier", "Has Lead", "Is Small Rip", "Can Small Rip", "Miner", "Builder" ]
    result = []
    for bit in range( 16 ):
        if( data & 1<<bit ):
            result.append( abilities[ bit ] )
    return ", ".join( result )

def getStationAttribs( data ):
    abilities = [ "Unload", "Start", "Restart", "Ripcord", "Capture", "Land", "Repair", "Remote Lead", "Reload", "Counts for Victory", "Pedestal", "TeleUnload", "Capship Land", "Rescue", "Rescue Any" ]
    result = []
    for bit in range( 16 ):
        if( data & 1<<bit ):
            result.append( abilities[ bit ] )
    return ", ".join( result )

def getAsteroidAttribs( data ):
    abilities = [ "He3", "Lots He3", "Gold", "Buildable", "Special" ]
    result = []
    for bit in range( 16 ):
        if( data & 1<<bit ):
            result.append( abilities[ bit ] )
    return ", ".join( result )

def getExpendableAttribs( data ):
    abilities = [ "Capture", "Resonator", "0x04", "QuickReady", "Ripcord", "Shoot Stations", "Shoot Ships", "Shoot Missiles", "0x100", "0x200", "0x400", "0x800", "Shoot Only Target", "Rescue", "Rescue Any" ]
    result = []
    for bit in range( 16 ):
        if( data & 1<<bit ):
            result.append( abilities[ bit ] )
    return ", ".join( result )
        
def getMask(data):
    values = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ]
    res = []
    for bit in range( 16 ):
        if( data & 1<<bit ):
            res.append( values[ bit ] )
    return " ".join( res ) 

def getTechTree( data ):
    res = []
    for i in range( len(data) ):
        for bit in range( 8 ):
            if( ord(data[i]) & 1<<bit ):
                res.append( str( i*8 + bit ) )
    return " ".join( res ) 

class Entity:
    def __init__(self, data):
        self.name = "Entity"
        self.attribs = {}
##        self.attribs[ "UID" ] = "NA"
        self.offset = 0
        
    def getAttrib(self, key):
        if not self.attribs.has_key(key):
            return "!" + key + "!"
        else:
           if type(self.attribs[key]) is float:
               return str( round( self.attribs[key], 2 ) )
           else:
               return str( self.attribs[key] ) 

    def setAttribs( self, names, format, data, offset ):
        data = struct.unpack( format, data[ offset : offset + struct.calcsize( format ) ] )
        for n,v in zip( names, data ):
            self.attribs[ n ] = v
        return struct.calcsize( format )

    def extendAttribs(self, entity, prefix = None):
        if entity == None: return
        for n,v in entity.attribs.iteritems():
            if prefix: self.attribs[prefix + n] = v
            else: self.attribs[n] = v

    def toString(self):
        return self.name + ":" + self.attribs[ "name" ]

class Hardpoint(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "Hardpoint"
        self.offset += self.setAttribs( ["int_sound","ext_sound"], "hh", data, self.offset )

        self.attribs[ "frame_name" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13 
        self.attribs[ "location" ] = getString( data[ self.offset : self.offset + 9 ] )
        self.offset += 9 
        self.offset += self.setAttribs( ["part_mask","fixed"], "Hb", data, self.offset )
        self.offset += 1 #data alignment
       
        self.attribs[ "part_mask_text" ] = getMask( self.attribs[ "part_mask" ] )
 
class GlobalAttribs(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "GAs"
        self.offset += self.setAttribs( ["max_speed","thrust","turn_rate","turn_torque","station_hull","station_hull_regen","station_shield","station_shield_regen","ship_hull","ship_shield","ship_shield_regen","scan_range","signature","max_energy","pw_range","ew_range","missile_turn_rate","mine_rate","mine_yield","mine_capacity","rip_time","damage_guns","damage_missiles","dev_cost","dev_time"], "25f", data, self.offset )
        
class Buyable(Entity):
    def __init__(self,data):
        Entity.__init__(self, data);
        self.name = "Buyable"
        self.offset += self.setAttribs( ["cost","time_to_build"], "iI", data, self.offset )
        self.attribs[ "model" ] = getString( data[ self.offset : self.offset + 14 ] )
        self.offset += 14
        self.attribs[ "icon" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.attribs[ "name" ] = getString( data[ self.offset : self.offset + 25 ] )
        self.offset += 25
        self.attribs[ "description" ] = getString( data[ self.offset : self.offset + 201 ] )
        self.offset += 201
        self.offset += self.setAttribs( ["group_id"], "b", data, self.offset )
        self.attribs[ "pre" ] = getTechTree( data[ self.offset : self.offset + 50 ] )
        self.offset += 50
        self.attribs[ "def" ] = getTechTree( data[ self.offset : self.offset + 50 ] )
        self.offset += 50
        self.offset += 2 # data boundry alignment

class Ship(Buyable):
    def __init__(self,data):
        Buyable.__init__(self,data)
        self.name = "Ship"
        self.offset += self.setAttribs( ["mass","sig","speed","yaw_max","pitch_max","roll_max","yaw_torque","pitch_torque","roll_torque","thrust","side_mult","rear_mult","scan","fuel","ecm","length","energy","recharge","rip_time","rip_cost"], "20f", data, self.offset )
        self.offset += self.setAttribs( ["ammo","hull_id","next_hull","weapons","fixed_weapons", "hp","hardpoint_offset","ac","missiles","dispenser","chaff"], "hhhbbfhhhhh", data, self.offset )
       
        defLoadout = []
        for i in struct.unpack( '14h', data[ self.offset : self.offset + struct.calcsize('14h') ] ):
            if( i != -1 ):
                defLoadout.append( str(i) + " " )
        self.attribs[ "loadout" ] = "".join( defLoadout )
        self.offset += struct.calcsize('14H')

        self.offset += self.setAttribs( ["hull_abilities"], "H", data, self.offset )
        self.attribs[ "hull_abilities_text" ] = getHullAttribs( self.attribs[ "hull_abilities" ] )

        self.attribs[ "texture" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13

        masks = []
        maskData = str( len(ET_NAMES) ) + 'H'
        for name in ET_NAMES:
            masks.append( name + "_mask" )
        self.offset += self.setAttribs( masks, maskData, data, self.offset )

        for name in ET_NAMES:
            self.attribs[ name + "_mask_text" ] = getMask( self.attribs[ name + "_mask" ] )

        self.offset += 1 #data alignment
        self.offset += self.setAttribs( ["int_sound","ext_sound","engine_int_sound","engine_ext_sound","thrust_int_sound","thrust_ext_sound"], '6H', data, self.offset )
       
        self.offset = self.attribs[ "hardpoint_offset" ]
        for i in range( 6 ):
            if i < self.attribs[ "weapons" ]: 
                hp = Hardpoint( data[ self.offset : ] )
                self.extendAttribs( hp, "hard" + str(i) + "_" )
                self.offset += hp.offset
            else:
                hp = Hardpoint( chr(0)*500 )
                self.extendAttribs( hp, "hard" + str(i) + "_" )
                self.offset += hp.offset
 
class Part(Buyable):
    def __init__(self, data):
        Buyable.__init__(self, data)
        self.name = "Part"        
        self.offset += self.setAttribs( ["mass","sig","part_id","next_id","type","mask"], "ffhhbH", data, self.offset )
        self.attribs[ "loadout_model" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.offset += 3 # data alignment

        self.attribs[ "type_text" ] = getType( self.attribs[ "type" ] )
        self.attribs[ "mask_text" ] = getMask( self.attribs[ "mask" ] )

class Weapon(Part):
    def __init__(self, data):
        Part.__init__(self, data)
        self.name = "Weapon"
        self.offset += self.setAttribs( ["ready_time","burst_time","energy_cost","dispersion","ammo_cost","proj_id","activate_sound","single_shot_sound","burst_sound"], "4f5h", data, self.offset )
                
class Shield(Part):
    def __init__(self, data):
        Part.__init__(self, data)
        self.name = "Shield"
        self.offset += self.setAttribs( ["regen_rate","hp","ac","activate_sound","deactivate_sound"], "2fb2h", data, self.offset )

class Cloak(Part):
    def __init__(self, data):
        Part.__init__(self, data)
        self.name = "Cloak"
        self.offset += self.setAttribs( ["drain","max_cloak","on_rate","off_rate","on_sound","off_sound"], "4f2h", data, self.offset )

class Booster(Part):
    def __init__(self, data):
        Part.__init__(self, data)
        self.name = "Booster"
        self.offset += self.setAttribs( ["fuel_use","max_thrust","on_rate","off_rate","on_sound","off_sound"], '4f2h', data, self.offset ) 

class Pack(Part):
    def __init__(self, data):
        Part.__init__(self, data)
        self.name = "Pack"
        self.offset += self.setAttribs( ["pack_type","amount"], "bh", data, self.offset )

class Launcher(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "Launcher"       
        self.offset += self.setAttribs( ["amount","part_id","next_id","launch_count","expendable_id"], "5h", data, self.offset )
        self.attribs[ "loadout_model" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13

class DataObject(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "DataObject"        
        self.offset += self.setAttribs( ["color_red","color_green","color_blue","color_alpha","radius","rotation"], "6f", data, self.offset )
        self.attribs[ "model" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.attribs[ "texture" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.offset += 2 #data alignment

class Projectile(DataObject):
    def __init__(self, data):
        DataObject.__init__(self, data)
        self.name = "Projectile"
        self.offset += self.setAttribs( ["damage","blast_damage","blast_radius","speed","lifetime","proj_id","dc","abs_dir","directional","width","sound_id"], "5fh3bfh", data, self.offset )

class LauncherDef(Buyable):
    def __init__(self, data):
        Buyable.__init__(self, data)
        self.name = "Launcher"       
        self.offset += self.setAttribs( ["sig","mass","part_mask","expend_size"], "2f2H", data, self.offset )

class Expendable(DataObject):
    def __init__(self, data):
        DataObject.__init__(self, data)
        self.name = "Expendable"
        self.offset += self.setAttribs( ["load_time","lifespan","sig"], "3f", data, self.offset )

        launcherDef = LauncherDef( data[ self.offset : ] )
        self.offset += launcherDef.offset

        self.extendAttribs( launcherDef, "ld_" )

        self.offset += self.setAttribs( ["hp","ac","id"], "fbh", data, self.offset )

        self.offset += self.setAttribs( ["abilities"], "h", data, self.offset )
        self.attribs[ "abilities_text" ] = getExpendableAttribs( self.attribs[ "abilities" ] )

        self.attribs[ "icon" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.offset += 1

        self.attribs[ "pre" ] = self.attribs["ld_pre"]
        self.attribs[ "def" ] = self.attribs["ld_def"]
        self.attribs[ "name" ] = self.attribs["ld_name"]
                
class Missile(Expendable):
    def __init__(self, data):
        Expendable.__init__(self, data)
        self.name = "Missile"        
        self.offset += self.setAttribs( ["accel","turn_rate","inital_speed","lock_time","ready_time","max_lock","resist","dispersion","lock_angle","power","blast_power","blast_radius","width","dc","directional","launch_sound","ambient_sound"], "13fbb2h", data, self.offset )

class Mine(Expendable):
    def __init__(self, data):
        Expendable.__init__(self, data)
        self.name = "Mine"        
        self.offset += self.setAttribs( ["radius","power","endurance","dc"], "3fb", data, self.offset )  

class Chaff(Expendable):
    def __init__(self, data):
        Expendable.__init__(self, data)
        self.name = "Chaff"
        self.offset += self.setAttribs( ["strength"], "f", data, self.offset )
        
class Probe(Expendable):
    def __init__(self, data):
        Expendable.__init__(self, data)
        self.name = "Probe"
        self.offset += self.setAttribs( ["scan","fire_time","dispersion","accuracy","ammo","proj_id","sound_id","rip_time"], "4f3hf", data, self.offset )

class Faction(Entity):
    def __init__(self, data):
        Entity.__init__(self,data)
        self.name = "Faction"        
        self.offset += self.setAttribs( ["income","bonus"], "2f", data, self.offset )
        self.attribs[ "name" ] = getString( data[ self.offset : self.offset + 25 ] )
        self.offset += 25
        self.attribs[ "icon" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.attribs[ "hud" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.attribs[ "base_tech" ] = getTechTree( data[ self.offset : self.offset + 50 ] )
        self.offset += 50
        self.attribs[ "no_dev_tech" ] = getTechTree( data[ self.offset : self.offset + 50 ] )
        self.offset += 50
        self.offset += 1 # do word align
        ga = GlobalAttribs( data[ self.offset : ] )
        self.offset += ga.offset
        self.extendAttribs( ga, "ga_" )
        self.offset += self.setAttribs( ["lifepod","civ_id","station"], "3h", data, self.offset )
        self.attribs[ "pre" ] = ""
        self.attribs[ "def" ] = self.attribs["base_tech"]

class Constants(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "Constants"        
        self.offset += self.setAttribs( ["lens_mult","radius_sector","out_of_bounds","exit_warp_speed","exit_station_speed","downed_shield","payday_time","capacity_he3","value_he3","amount_he3","mount_rate","starting_money","win_money","ripcord_time","he3_regen","points_warp","points_asteroid","points_tech","points_miner","points_builder","points_layer","points_carrier","points_player","points_base_kill","points_base_capture","points_flags","points_artifacts","points_rescues","rating_add","rating_divide","income","lifepod_time","aleph_bomb_delay","lifepod_cost","turret_cost","drone_cost","player_cost","base_cluster_cost","cluster_divisor" ], "39f", data, self.offset )
        self.offset += struct.calcsize( 'f' ) #skip 40th unused constant

        self.dmgTable = struct.unpack( "400f", data[ self.offset : self.offset + struct.calcsize( "400f" ) ] )
        self.offset += struct.calcsize( "400f" )

class Tech(Buyable):
    def __init__(self, data):
        Buyable.__init__(self, data)
        self.name = "Tech"
        ga = GlobalAttribs( data[ self.offset : ] )
        self.offset += ga.offset
        self.extendAttribs( ga, "ga_" )
        self.offset += self.setAttribs( ["dev_id","complete_sound"], "2h", data, self.offset )

class Drone(Buyable):
    def __init__(self, data):
        Buyable.__init__(self, data)
        self.name = "Drone"        
        self.offset += self.setAttribs( ["shoot_skill","move_skill","bravery","pilot_type","hull_id","drone_type_id","expendable_id"], "3fb3h", data, self.offset )
        self.attribs[ "pilot_type_text" ] = getPilotType( self.attribs[ "pilot_type" ] )

class Station(Buyable):
    def __init__(self, data):
        Buyable.__init__(self, data)
        self.name = "Station"
        self.offset += self.setAttribs( ["sig","hull_hp","shield_hp","hull_regen","shield_regen","scan","income","radius"], "6fif", data, self.offset )
        self.attribs[ "local_tech" ] = getTechTree( data[ self.offset : self.offset + 50 ] )
        self.offset += 50
        self.offset += self.setAttribs( ["station_id","next_station_id","hull_ac","shield_ac","station_abilities","builds_on","station_class","con_drone","con_need_rock_sound","con_under_attack_sound","con_destroyed_sound","build_complete_sound","interior_sound","exterior_sound","interior_alert_sound","under_attack_sound","critical_sound","destroyed_sound","captured_sound","enemy_captured_sound","enemy_destroyed_sound"], "2h2b2hb14h", data, self.offset )
        self.attribs[ "texture" ] = getString( data[ self.offset : self.offset + 13 ] )
        self.offset += 13
        self.attribs[ "builder_name" ] = getString( data[ self.offset : self.offset + 25 ] )

        self.attribs[ "station_class_text" ] = getStationClass( self.attribs[ "station_class" ] )
        self.attribs[ "station_abilities_text" ] = getStationAttribs( self.attribs[ "station_abilities" ] )
        self.attribs[ "def" ] += self.attribs["local_tech"]

class TreasureSet(Entity):
    def __init__(self, data):
        Entity.__init__(self, data)
        self.name = "TreasureSet"        
        self.attribs[ "name" ] = getString( data[ self.offset : self.offset + 25 ] )
        self.offset += 25
        self.offset += self.setAttribs( [ "treasure_id", "tresure_count", "zone_only" ], "hhb", data, self.offset )
        self.attribs[ "data" ] = data[ self.offset : ]
    
class IGCReader:
    def __init__(self):
        self.ships = []
        self.factions = []
        self.parts = []
        self.weapons = []
        self.shields = []
        self.cloaks = []
        self.missiles = []
        self.mines = []
        self.probes = []
        self.projectiles = []
        self.stations = []
        self.chaff = []
        self.drones = []
        self.techs = []
        self.boosters = []
        self.treasureset = []
        self.corePath = ""

    def getCoreName(self):
        return self.corePath[0 : self.corePath.rfind(".")]
        
    def open( self, path ):
        self.corePath = path
        self.ships = []
        self.factions = []
        self.parts = []
        self.weapons = []
        self.shields = []
        self.cloaks = []
        self.missiles = []
        self.mines = []
        self.probes = []
        self.projectiles = []
        self.stations = []
        self.chaff = []
        self.drones = []
        self.techs = []
        self.boosters = []
        self.treasureset = []
        self.launchers = []
        self.extractCoreData()

    def save( self, path ):
        data = file( path, "wb+" )

    def extractCoreData(self):
        data = file( self.corePath, "rb" ).read()
        magic = struct.unpack( 'cccc', data[0:4] )
        print "Magic :", magic
        
        size = struct.unpack( 'i', data[4:8] )[0] 
        offset = 8

        while( offset < size ):
            tag = struct.unpack( 'h', data[offset : offset + 2] )[0]
            tSize = struct.unpack( 'i', data[offset + 2 : offset + 6 ] )[0]
            offset = offset + 6 

            if tag == OT_HULLTYPE:
                self.ships.append( Ship( data[offset : offset+tSize] ) )
            elif tag == OT_FACTION:
                self.factions.append( Faction( data[offset : offset+tSize] ) )
            elif tag == OT_PARTTYPE:
                if tSize > 378:                
                    p = Part( data[ offset : offset+tSize ] )
                    if( p.attribs[ "type" ] == ET_WEAPON ):
                        self.weapons.append( Weapon( data[ offset : offset+tSize ] ) )
                    elif( p.attribs[ "type" ] == ET_SHIELD ):
                        self.shields.append( Shield( data[ offset : offset+tSize ] ) )
                    elif( p.attribs[ "type" ] == ET_CLOAK ):
                        self.cloaks.append( Cloak( data[ offset : offset+tSize ] ) )
                    elif( p.attribs[ "type" ] == ET_BOOSTER ):
                        self.boosters.append( Booster( data[ offset : offset+tSize ] ) )
                    else:
                        self.parts.append( p )
                else:
                    self.launchers.append( Launcher( data[ offset : offset+tSize ] ) )
            elif tag == OT_CONSTANTS:
                self.const = Constants( data[ offset : offset + tSize ] )
            elif tag == OT_MISSILETYPE:
                self.missiles.append( Missile( data[ offset : offset + tSize ] ) )
            elif tag == OT_MINETYPE:
                self.mines.append( Mine( data[ offset : offset + tSize ] ) )
            elif tag == OT_PROBETYPE:
                self.probes.append( Probe( data[ offset : offset + tSize ] ) )
            elif tag == OT_PROTECTILETYPE:
                self.projectiles.append( Projectile( data[ offset : offset + tSize ] ) )
            elif tag == OT_STATIONTYPE:
                self.stations.append( Station( data[ offset : offset + tSize ] ) )
            elif tag == OT_CHAFFTYPE:
                self.chaff.append( Chaff( data[ offset : offset + tSize ] ) )
            elif tag == OT_DRONETYPE:
                self.drones.append( Drone( data[ offset : offset + tSize ] ) )
            elif tag == OT_TECH:
                self.techs.append( Tech( data[ offset : offset + tSize ] ) )
            elif tag == OT_TREASURESET:
                self.treasureset.append( TreasureSet( data[ offset : offset + tSize ] ) )
            offset = offset + tSize

##    def createTechTree(self):
##        return
##    
##        nodes = []
##        nodes.extend( self.parts )
##        nodes.extend( self.missiles )
##        nodes.extend( self.mines )
##        nodes.extend( self.probes )
##        nodes.extend( self.chaff )
##        nodes.extend( self.factions )
##        nodes.extend( self.techs )
##        nodes.extend( self.stations )
##        nodes.extend( self.ships )
##
##        self.defMap = {}
##        self.preMap = {}
##        for i in range(400):
##            self.defMap[str(i)] = []
##            self.preMap[str(i)] = []
##
##        for n in nodes:
##            defs = n.attribs["Def"].split()
##            pres = n.attribs["Pre"].split()
##            for d in defs:
##                self.defMap[d].append( n )
##            for p in pres:
##                self.preMap[p].append( n )
##
##    def getEntity(self, ents, uid):
##        if uid == -1: return None
##        for e in ents:
##            if e.attribs["UID"] == uid: return e
##
##    def getProjectile(self, uid):
##        return self.getEntity(self.projectiles, uid)
##
##    def linkWeaponData(self):
##        for w in self.weapons:
##            w.extendAttribs( self.getProjectile( w.attribs["Proj UID"] ) )
##            if w.attribs["Proj UID"] != -1: w.attribs["DPS"] = (w.attribs["Damage"] + w.attribs["Area Damage"])/w.attribs["ROF"]
##
##        for p in self.probes:
##            p.extendAttribs( self.getProjectile( p.attribs["Projectile"] ) )
##            if p.attribs["Projectile"] != -1: p.attribs["DPS"] = (p.attribs["Damage"] + p.attribs["Area Damage"])/p.attribs["Shot Interval"]
##
##