if (!second) {

        return first;

    }

    second = [second stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];

    if (first) {

        if ([first rangeOfString:second options:NSCaseInsensitiveSearch].location==NSNotFound) {

            if ([second rangeOfString:first options:NSCaseInsensitiveSearch].location==NSNotFound) {

                return [NSString stringWithFormat:@"%@; %@",first,second];

            }

            return second;

        }

        return first;

    }

    return second;

    NSString* result = part;

        io_object_t nextParent = 0;

        while ((nextParent = IOIteratorNext(parentsIterator))) {

            NSDictionary* props = nil;

            NSString* image = nil;

            NSString* partition = nil;

            NSString* connection = nil;

            kernResult = IORegistryEntryCreateCFProperties(nextParent,(CFMutableDictionaryRef*)&props,kCFAllocatorDefault,0);

            if (IOObjectConformsTo(nextParent,"IOApplePartitionScheme")) {

                partition = [props objectForKey:@"Content Mask"];

            } else if (IOObjectConformsTo(nextParent,"IOMedia")) {

                partition = [props objectForKey:@"Content"];

            } else if (IOObjectConformsTo(nextParent,"IODiskImageBlockStorageDeviceOutKernel")) {

                NSData* data = nil;

                    image = [[[NSString alloc] initWithBytes:[data bytes] length:[data length] encoding:NSUTF8StringEncoding] autorelease];

                }

            } else if (IOObjectConformsTo(nextParent,"IOHDIXHDDriveInKernel")) {

                image = [props objectForKey:@"KDIURLPath"];

            }

            NSDictionary* subdict;

                connection = [subdict objectForKey:@"Physical Interconnect"];

            } else {

                connection = [props objectForKey:@"Physical Interconnect"];

            }

            if (connection) {

                [dict setObject:AddPart([dict objectForKey:NSWorkspace_RBconnectiontype],connection) forKey:NSWorkspace_RBconnectiontype];

            }

            if (partition) {

                [dict setObject:partition forKey:NSWorkspace_RBpartitionscheme];

            }

            if (image) {

                [dict setObject:image forKey:NSWorkspace_RBimagefilepath];

            }

            NSString* value;

                    result = AddPart(result,value);

                }

                    result = AddPart(result,value);

                }

                    result = AddPart(result,value);

                }

            }

                result = AddPart(result,value);

            }

                result = AddPart(result,value);

            }

            NSString* cls = [(NSString*)IOObjectCopyClass(nextParent) autorelease];

            if (![cls isEqualToString:@"IOPCIDevice"]) {

//              NSLog(@"=================================> %@:%@\n",cls,props);

                result = CheckParents(nextParent,result,dict);

            }

            IOObjectRelease(nextParent);

        }

        IOObjectRelease(parentsIterator);

    return result;

    UInt8* work = ((UInt8*)mountInfo)+mountInfo->serverNameOffset;

    if (devdesc) {

        *devdesc = [[[NSString alloc] initWithBytes:&work[1] length:work[0] encoding:NSUTF8StringEncoding] autorelease];

    }

    work = ((UInt8*)mountInfo)+mountInfo->volNameOffset;

    NSString* volname = [[[NSString alloc] initWithBytes:&work[1] length:work[0] encoding:NSUTF8StringEncoding] autorelease];

    work = ((UInt8*)mountInfo)+mountInfo->alternateAddressOffset;

    AFPAlternateAddress* afpa = (AFPAlternateAddress*)work;

    AFPTagData* afpta = (AFPTagData*)(&afpa->fAddressList);

    NSString* ip = nil;

    NSString* dns = nil;

    int i = afpa->fAddressCount;

    while ((i-->0)) {

        switch (afpta->fType) {

            case kAFPTagTypeIP:

                if (!ip) {

                    ip = [[[NSString alloc] initWithBytes:&afpta->fData[0] length:afpta->fLength-2 encoding:NSUTF8StringEncoding] autorelease];

                }

                break;

            case kAFPTagTypeIPPort:

                ip = [NSString stringWithFormat:@"%u.%u.%u.%u:%u",afpta->fData[0],afpta->fData[1],afpta->fData[2],afpta->fData[3],OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[4])];

                break;

            case kAFPTagTypeDNS:

                dns = [[[NSString alloc] initWithBytes:&afpta->fData[0] length:afpta->fLength-2 encoding:NSUTF8StringEncoding] autorelease];

                break;

            case 0x07:

                ip = [NSString stringWithFormat:@"[%x:%x:%x:%x:%x:%x:%x:%x]",OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[0]),

                    OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[2]),OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[4]),

                    OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[6]),OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[8]),

                    OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[10]),OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[12]),

                    OSSwapBigToHostInt16(*(UInt16*)&afpta->fData[14])];

                break;

        }

        afpta = (AFPTagData*)((char*)afpta+afpta->fLength);

    }

    return [NSString stringWithFormat:@"afp://%@/%@",dns?:(ip?:@""),volname];

    const char* ccpath = (const char*)[path fileSystemRepresentation];

    NSMutableDictionary* result = nil;

    struct statfs fs;

    if (!statfs(ccpath,&fs)) {

        NSString* from = [NSString stringWithUTF8String:fs.f_mntfromname];

        result = [NSMutableDictionary dictionaryWithObjectsAndKeys:

            [NSString stringWithUTF8String:fs.f_fstypename],NSWorkspace_RBfstypename,

            [NSString stringWithUTF8String:fs.f_mntonname],NSWorkspace_RBmntonname,

            nil];

        if (strncmp(fs.f_mntfromname,"/dev/",5)==0) {

            mach_port_t masterPort = 0;

            io_iterator_t mediaIterator = 0;

            kern_return_t kernResult = IOMasterPort(bootstrap_port,&masterPort);

            if (kernResult==KERN_SUCCESS) {

                CFMutableDictionaryRef classesToMatch = IOBSDNameMatching(masterPort,0,&fs.f_mntfromname[5]);

                if (classesToMatch) {

                    kernResult = IOServiceGetMatchingServices(masterPort,classesToMatch,&mediaIterator);

                    if ((kernResult==KERN_SUCCESS)&&mediaIterator) {

                        io_object_t firstMedia = 0;

                        while ((firstMedia = IOIteratorNext(mediaIterator))) {

                            NSString* stuff = CheckParents(firstMedia,nil,result);

                            if (stuff) {

                                [result setObject:stuff forKey:NSWorkspace_RBdeviceinfo];

                            }

                            IOObjectRelease(firstMedia);

                        }

                    }

                }

            }

            if (mediaIterator) {

                IOObjectRelease(mediaIterator);

            }

            if (masterPort) {

                mach_port_deallocate(mach_task_self(),masterPort);

            }

        }

        //Don't need this for disk images, gets around warnings for some deprecated functions

        /* else {

            FSRef ref;

            if (FSPathMakeRef((const UInt8*)ccpath,&ref,NULL)==noErr) {

                FSCatalogInfo info;

                if (FSGetCatalogInfo(&ref,kFSCatInfoVolume,&info,NULL,NULL,NULL)==noErr) {

                    ParamBlockRec pb;

                    UInt16 vmisize = 0;

                    VolumeMountInfoHeaderPtr mountInfo = NULL;

                    pb.ioParam.ioCompletion = NULL;

                    pb.ioParam.ioNamePtr = NULL;

                    pb.ioParam.ioVRefNum = info.volume;

                    pb.ioParam.ioBuffer = (Ptr)&vmisize;

                    pb.ioParam.ioReqCount = sizeof(vmisize);

                    if ((PBGetVolMountInfoSize(&pb)==noErr)&&vmisize) {

                        mountInfo = (VolumeMountInfoHeaderPtr)malloc(vmisize);

                        if (mountInfo) {

                            pb.ioParam.ioBuffer = (Ptr)mountInfo;

                            pb.ioParam.ioReqCount = vmisize;

                            if (PBGetVolMountInfo(&pb)==noErr) {

                                NSString* url = nil;

                                switch (mountInfo->media) {

                                case AppleShareMediaType:

                                    url = FormatAFPURL((AFPXVolMountInfoPtr)mountInfo,&from);

                                    break;

                                case 'http':

                                    url = from;

                                    break;

                                case 'crbm':

                                case 'nfs_':

                                case 'cifs':

                                    url = [NSString stringWithUTF8String:(char*)mountInfo+sizeof(VolumeMountInfoHeader)+sizeof(OSType)];

                                    break;

                                }

                                if (url) {

                                    [result setObject:url forKey:NSWorkspace_RBserverURL];

                                }

                            }

                        }

                        free(mountInfo);

                    }

                }

            }

        }*/

        [result setObject:from forKey:NSWorkspace_RBmntfromname];

    }

    return result;