iOS项目开发中的知识点与问题收集整理②（Part 二）

1、点击UIButton 无法产生触摸事件   

如果在UIImageView中添加了一个按钮，你会发现在默认情况下这个按钮是无法被点击的，需要设置UIImageView的userInteractionEnabled为YES：

imageView.userInteractionEnabled = YES;
设置为YES后，UIImageView内部的按钮就可以被点击了

2、如何启动app时全屏显示Default.png（图片）？  

大部分app在启动过程中全屏显示一张背景图片，比如新浪微博会显示这张：

要想在iOS中实现这种效果，毫无压力，非常地简单，把需要全屏显示的图片命名为Default.png即可，在iOS app启动时默认会去加载并全屏显示Default.png。

也可以用其他名称来命名图片，在Info.plist配置一下即可：

配置过后，app启动时就会去加载并全屏显示lufy.png

在默认情况下，app显示Default.png时并非真正的"全屏显示"，因为顶部的状态栏并没有被隐藏，比如下面的效果：

大部分情况下，我们都想隐藏状态栏，让Default.png真正全屏显示。

说到这里，可能有人马上就想到了一种办法：在AppDelegate的application:didFinishLaunchingWithOptions:方法中添加如下代码：

[UIApplication sharedApplication].statusBarHidden = YES;
我只能说你的思路是对的，但实际上达不到想要的效果，你会发现显示Default.png时状态栏还是存在的，等Default.png显示完毕后，状态栏才被隐藏。

我先解释下为什么这种方法不可行，其实原因很简单：

1> Default.png是在app启动过程中加载的，并不是在app启动完毕后再加载的

2> AppDelegate的application:didFinishLaunchingWithOptions:方法是在app启动完毕后才调用的

下面说一下解决方案，在Info.plist中增加一个配置即可：

这里的YES表示在app初始化(启动)的时候就隐藏状态栏。

当然，在Default.png显示完毕后状态栏还是隐藏的。如果想重新显示状态栏，补上下面代码即可：

[UIApplication sharedApplication].statusBarHidden = NO;

3、使用ASIHTTPRequest保存cookies   

假如我的APP，第一次启动请求了登录接口并得到了Cookie，然后我把APP关了，下次启动APP，我不请求登录接口了，

那上次得到的Cookie就不存在了。如果需要，那么2种方法，下次启动app，自动登入，这样能得到服务器分配给你的cookier

（这一种是最好的，因为session也会过期），还有一种是你把上次登入的时候，拿到的cookier存起来，然后下次启动app的时候，

手动给请求（ASIHTTP）添加cookie。所以当第一次登录成功后，可以把cookie保存到CoreData，SQLite，UserDefault等，

等到下次网络请求时，读取：

  ASIFormDataRequest *request = [ASIFormDataRequest requestWithURL:UserInfoURL];
 [request setRequestMethod:@"POST"];
  [request addRequestHeader:@"Cookie" value:[NSString stringWithFormat:@"cookie=%@",[[NSUserDefaults standardUserDefaults] objectForKey:@"cookie"]]];
 //把cookie的值放进Header里，这个cookie的值是一串很长的字符串。 

4、设置UITextField只有当有字符输入后，键盘右下角的搜索/返回/done/等等键才可以使用  

TextField设置这个属性为YES就可以了，默认为NO

searchField.enablesReturnKeyAutomatically =YES;

5、类似QQ等IM软件，长度和高度不一的聊天气泡的图片是如何做的？拉伸？  

其实是一个小气泡png，然后拉伸中间部分，四个角不拉动，就是局部拉伸。ios自带方法，四个角可以不拉伸的，如下：

6、UITableView中有多个UITextField时，被挡住的TextField如何实现自动向上弹起？   

首先要实现TextField的delegate，在方法：

 - (void)textFieldDidBeginEditing:(UITextField *)textField {
     [self.tableView setContentOffset:CGPointMake(, ) animated:YES];
 }  

这说明当开始输入时，tableview在原来的基础上向上抬起70个距离。多个UITextFiled可以通过判断来使用CGPoint的调整高度，我这写的是70.
tableview的scrollEnabled属性一定要是YES;要不然滚动不了了。
记得在return时复原tableview的位置：

 - (BOOL)textFieldShouldReturn:(UITextField *)sender {
     [self.tableView setContentOffset:CGPointMake(, ) animated:YES];
     return YES;
 }   

7、ios如何在调试时，轻松找到程序在哪里崩溃？  

我们给自己的工程添加一个全局的断点：

一步步按上面图完成操作。
再运行程序

自动就断点到这里来了，
log信息是:

-- ::19.635 GestureRecognizer[:c07] -[__NSCFNumber isEqualToString:]: unrecognized selector sent to instance 0x7a88df0
-- ::21.148 GestureRecognizer[:c07] *** Terminating app due to uncaught exception 'NSInvalidArgumentException',
 reason: '-[__NSCFNumber isEqualToString:]: unrecognized selector sent to instance 0x7a88df0'  

这样很简单就能发现程序崩溃是因为value没有 isEqualToString方法。如果没加上面这个通用的断点，那程序会直接断点到main函数去。

8、UIImageView 如何实现windows 桌面类似的背景壁纸屏幕（很小的图片会显示N多个）？ 

从UImageView上找ContentMode或clipToBounds是都不管用的，正确的办法是，不用UImageView，使用UIView，然后设置backgroundColor属性为我们的图片，这样的话自动会以屏幕的方式显示。

 UIView *gridView = [[UIView alloc] initWithFrame:CGRectMake(, , , )];
 gridView.backgroundColor = [UIColor colorWithPatternImage:BUNDLE_IMAGE(@"blue_grid")];
 [self.view addSubview:gridView];
 [gridView release];  

下图所示：（原图是一个6X6的方格）

9、UITableViewCell 的backgroundColor不起作用的问题？   

在开发时，想要在tableview中的某一个Cell设置选中状态，并且Cell的背景颜色是一个自定义颜色。

  -(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{  

  <span style="white-space:pre">  </span>//省略....
      cell.textLabel.font = [UIFont systemFontOfSize:6.0];
      cell.textLabel.text = @"";  

      if (indexPath.row==) {
         [cell setBackgroundColor:[UIColor colorWithRed:100.0f/255.0f green:176.0f/255.0f blue:0.0f/255.0f alpha:1.0f]];
     }
     else{
         [cell setBackgroundColor:[UIColor whiteColor]];
     }  

     return cell;
 }   

这样的话，第1行cell就应该是我们设置好的颜色，不过请注意，此方法在UITableViewStylePlain的风格下有效，在 UITableViewStyleGrouped的样式下是无效的！这个跟tableview的backgroundView和backgroundColor是没有关系的，个人猜想应该是在Grouped风格下，cell选中的颜色有系统的view遮罩，导致我们设置的无法显示出来。
【补充】如果想在reload或init时设置tableview的某一cell为 selected状态，千万不要使用cell setSelected:YESanimated:YES，使用tableview的方法：

 NSIndexPath *indexPath = [NSIndexPath indexPathForRow:i inSection:];
 terminalTableView selectRowAtIndexPath:indexPath animated:YES scrollPosition:UITableViewScrollPositionNone];   

10、UITableViewCell选中时contentView中各组件的高亮状态   

使用系统或简单自定义的UITableViewCell时，当选中某一行Cell后，除了背景颜色改变外，Cell上所有的组件（数据）比如UILabel，UIbutton等都被自动显示成了其

Highlighted（高亮）状态下的效果，（如果想显示出效果，你的那些自定义的组件必须要设置高亮状态，比如highlightedTextColor，UIControlStateHighlighted等），

所以这一点需要特别注意，如果不想要系统的这个自动特效，有两个解决办法：

1，组件不设置highlighted下的属性

2，如果自定义的Cell：

  - (void)setSelected:(BOOL)selected animated:(BOOL)animated
  {
      [super setSelected:selected animated:animated];
      if (selected) {
          //强制系统在UITableViewCell选中时SettingButton组件的高亮状态为NO
          [(UIButton *)[self.contentView.subviews objectAtIndex:] setHighlighted:NO];
          [settingBtn setImage:BUNDLE_IMAGE(@"accessory_sel") forState:UIControlStateNormal];
     }
     else{
         [settingBtn setImage:BUNDLE_IMAGE(@"accessory_nor") forState:UIControlStateNormal];
     }
 }     

11、IOS atomic与nonatomic，assign,copy与retain的定义和区别   

atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。
        atomic
                设置成员变量的@property属性时，默认为atomic，提供多线程安全。
                在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。加了atomic，setter函数会变成下面这样：
                        {lock}
                                if (property != newValue) {
                                        [property release];
                                        property = [newValue retain];
                                }
                        {unlock}
        nonatomic
        禁止多线程，变量保护，提高性能。
        atomic是Objc使用的一种线程保护技术，基本上来讲，是防止在写未完成的时候被另外一个线程读取，造成数据错误。而这种机制

是耗费系统资源的， 所以在iPhone这种小型设备上，如果没有使用多线程间的通讯编程，那么nonatomic是一个非常好的选择。

指出访问器不是原子操作，而默认地，访问器是原子操作。这也就是说，在多线程环境下，解析的访问器提供一个对属性的安全访

问，从获取器得到的返回值或者通过设置器设置的值可以一次完成，即便是别的线程也正在对其进行访问。如果你不指定 nonato

mic，在 自己管理内存的环境中，解析的访问器保留并自动释放返回的值，如果指定了 nonatomic ，那么访问器只是简单地返回

这个值。

assign
        对基础数据类型 （NSInteger，CGFloat）和C数据类型（int, float, double, char）等等。
        此标记说明设置器直接进行赋值，这也是默认值。在使用垃圾收集的应用程序中，如果你要一个属性使用assign，且这个类符合

NSCopying协 议， 你就要明确指出这个标记，而不是简单地使用默认值，否则的话，你将得到一个编译警告。这再次向编译器

说明你确实需要赋值，即使它是可拷贝的。

retain
        对其他NSObject和其子类对参数进行release旧值，再retain新值
        指定retain会在赋值时唤醒传入值的retain消息。此属性只能用于Objective-C对象类型，而不能用于Core Foundation对象。

(原因很明显，retain会增加对象的引用计数，而基本数据类型或者Core Foundation对象都没有引用计数——译者注)。

注意: 把对象添加到数组中时，引用计数将增加对象的引用次数+1。

copy
        对NSString 它指出，在赋值时使用传入值的一份拷贝。拷贝工作由copy方法执行，此属性只对那些实行了NSCopying协议

的对象类型有效。更深入的讨论 ，请参考“复制”部分。

copy与retain：
Copy其实是建立了一个相同的对象，而retain不是：
1.比如一个NSString 对象，地址为0×1111 ，内容为@”STR”，Copy 到另外一个NSString 之后，地址为0×2222 ，内容相同。
2.新的对象retain为1 ，旧有对象没有变化retain 到另外一个NSString 之后，地址相同（建立一个指针，指针拷贝），内容当然相同，

这个对象的retain值+1。
总结：retain 是指针拷贝，copy 是内容拷贝。

assign与retain：
1. 接触过C，那么假设你用malloc分配了一块内存，并且把它的地址赋值给了指针a，后来你希望指针b也共享这块内存，于是你又

把a赋值 给（assign）了b。 此时a和b指向同一块内存，请问当a不再需要这块内存，能否直接释放它？答案是否定的，因为a并不

知道b是否还在 使用这块内存，如果a释放了，那么b在使用这块内存的时候会引起程序crash掉。

2. 了解到1中assign的问题，那么如何解决？最简单的一个方法就是使用引用计数（reference counting），还是上面的那个例子，

我们给 那块内存设一个引用计数， 当内存被分配并且赋值给a时，引用计数是1。当把a赋值给b时引用计数增加到2。这时如果a

不再使用这块内存， 它只需要把引用计数减1，表明自己不再拥有这块内存。b不再使用这块内存时也把引用计数减1。当引用计数

变为0的时候，代表该内存不再  被任何指针所引用，系统可以把它直接释放掉。

总结：

上面两点其实就是assign和retain的区别，assign就是直接赋值，从而可能引起1中的问题，当数据为int, float等原生类型时，

可以使用assign。retain就如2中所述，使用了引用计数，retain引起引用计数加1, release引起引用计数减1，当引用计数为

0时，dealloc函数被调用，内存被回收。

12、#pragma mark -#pragma mark Initialization含义  

它们告诉Xcode编译器，要在编辑器窗格顶部的方法和函数弹出菜单中将代码分隔开;注意 #pragma mark – 的“-”后面不能有空格。如果你的标志没有

出现在弹出菜单中，比如没有分隔线出现，请在Xcode菜单 “Preferences..”中的 “Code Sense”选项取消选中”Sort listalphabetically”即可。

13、自定义delegate变量声明时使用assign还是retain？   

我们通过发送消息给对象出发特定动作;对象发送某些变化的时候通过回调函数(callback)通知我们。对象在特定事件发生的时候，就会调用对应的回调函数，

触发业务逻辑。回调函数通过所谓的代理(Delegation)来实现.

delegate使用方法：

@property (assign) <id>xxxDelegate delegate;

正确的使用方法是使用assign属性而不是retain。之所以对于delegate这类对象使用assign而不是用retain是为了防止循环retain（retain loop）

14、给成员变量（属性）赋值时使不使用self？   

使用@property和@synthesize声明一个成员变量，给其赋值是时要在前面加上"self."，以便调用成员变量的setmember方法。直接调用成员变量并且给其赋值：

member=[NSString stringWithFormat:@””];将不执行setmember 方法。
使用self调用成员变量并且给其赋值：self.member=[NSString stringWithFormat:@””];将执行setmember方法。

15、如何给UIbutton 同时设置图片（Image）和文字（Title）以及它们的各种状态？ 

 startRangeButton = [UIButton buttonWithType:UIButtonTypeCustom];
  startRangeButton.frame = CGRectMake(,componentOriginY, regionImage.size.width, );
 [startRangeButton setBackgroundImage:regionImage forState:UIControlStateNormal];
 //还可以设置其高亮状态startRangeButton setBackgroundImage:regionImage forState:UIControlStateHighlighted];
  startRangeButton.titleLabel.font = [UIFont systemFontOfSize:7.0];
 [startRangeButton setTitle:@"2013-08-01 07:00" forState:UIControlStateNormal];
 [startRangeButton setTitleColor:COLOR(, , , ) forState:UIControlStateNormal];
 [startRangeButton setTitleColor:[UIColor whiteColor] forState:UIControlStateHighlighted];  

代码中我设置button背景图片为自己定义的一个regionImage，并设置了button的title = “2013-08-01 07:00”【注意，设置了背景图片后，title只能这样添加，以button.titleLabel.text方式添加会无法显示的】，并且设置了tiitle正常和高亮下文字颜色。
所以看到这里，应该明白button.setBackgroundImage 和 set Image 的区别了吧，前者是可以同时设置文字，后者是一旦设置了image，无法再显示文字。

普通：高亮：

16、如何将NSDate类型转化为距离1970/1/1的毫秒差?   

[formatter setDateFormat:@"yyyy-MM-dd HH:mm"];  这种格式得到的数值是精确到秒的，也就是说少1000，

但是尝试[formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"];或SS大写，或[formattersetDateFormat:@"yyyy-MM-dd HH:mm.ss.SSS"];都不起作用，最后才发现，

原来是这样

NSTimeInterval本身是个秒级别的double类型数值，小数点后面即毫秒数,*1000.0f即可得到毫秒级别的时间差

 //为了兼容java版本，事件是从1970/1/1开始

  -(NSDate *)getDateTimeFromMilliSeconds:(long long) miliSeconds
  {
      NSTimeInterval tempMilli = miliSeconds;

      NSTimeInterval seconds = tempMilli/1000.0;

     NSLog(@"seconds=%f",seconds);

     return [NSDate dateWithTimeIntervalSince1970:seconds];
 }

 //将NSDate类型的时间转换为NSInteger类型,从1970/1/1开始

 -(long long)getDateTimeTOMilliSeconds:(NSDate *)datetime
 {
     NSTimeInterval interval = [datetime timeIntervalSince1970];    

     NSLog(@"interval=%f",interval);

     long long totalMilliseconds = interval* ;

     NSLog(@"totalMilliseconds=%llu",totalMilliseconds);

     return totalMilliseconds;
 } 

也就是说，计算结果再自己乘以1000就可以了

  NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
  [formatter setDateFormat:@"yyyy-MM-dd HH:mm"];  

  NSDate *sDate  = [formatter dateFromString:startRangeButton.titleLabel.text];
  NSDate *eDate = [formatter dateFromString:endRangeButton.titleLabel.text];
  NSTimeInterval sinterval =  [sDate timeIntervalSince1970];
  long long start = sinterval*;
  NSTimeInterval einterval = [eDate timeIntervalSince1970];
  long long end = einterval*;
 [mConnectionHelper doTrack:mobile startTime:start endTime:end];   

17、ios中的全局静态变量  

Objective-C 支持全局变量
主要有两种实现方式：
（1）第一种和C/C++中的一样， 使用"extern"关键词；
（2）另外一种就是使用单例实现。
（比如我们经常会把一个变量放在AppDelegate里面作为全局变量来访问， 其中AppDelegate就是一个单例类）

在Objective-C中如何实现像C++中那样的静态成员变量呢？
你需要做的是在一个类A的implementation(.m或者.mm)文件中定义一个static变量，然后为A类定义静态成员函数（class method，也就是类方法）来操作该变量。

 //example.h
 @interface Example : NSObject {     

 }
 - (id)init;
 +(int)instanceCount;
 @end    

  //example.m
   #import "example.h"
  static int count;
  @implementation Example
  -(id)init{
      self = [super init];
      if(nil!=self){
          count+=;
      }
  return self;
 }
 +(int)instanceCount{
      return count;
 }
 @end    

上面的例子中你就可以通过[Example instanceCount]对静态变量count进行访问，无须创建实例。
警告:  static 写在interface外面编译是没有错误的，但是编译器会报警告，这么说这样的写法是不被编辑器认可的。
错误：static 写在interface里面会直接报错，显然这样的语法是不被认可的。

static关键字声明的变量必须放在implementation外面，或者方法中，如果不为它赋值默认为0，
它只在程序开机初始化一次。

18、如何使用 NSNotificationCenter 在viewcontroller之间进行传值？ 

简单点的来，两个界面间传值，直接上代码了：

sendViewcontroller.m

  //SettingViewController ：接受值的viewcontroller
  SettingViewController *setting = [[SettingViewController alloc] init];
  [[NSNotificationCenter defaultCenter] addObserver:setting selector:@selector(received:) name:@"msetting" object:nil];
  NSDictionary *dict = [[NSDictionary alloc] initWithObjectsAndKeys:@"user",@"type", nil];  

  [[NSNotificationCenter defaultCenter] postNotificationName:@"msetting" object:dict];
  [self.navigationController pushViewController:setting animated:YES];  

  [setting release];
 SettingViewController.m（接收值的viewcontroller）

 -(void)received:(NSNotification *)notification{  

     id data = [notification object];
     NSLog(@"received data: %@",data);
 }  

这样就实现了基本的使用，跟delegate类似，注意 addObserver时，需要写目标viewcontroller的实例，而不是self。

19、Thread EXC_BAD_ACCESS : objc_retain, objc_getProperty 崩溃错误 

如上图所示，遇到这个错误，从字面的意思我们大致能猜到，是有属性已经被release掉了，但是我们又使用它了，所以，一部一部排查把，一定有某个地方的属性

提前被release掉了，自己手动管理内存就会有这样的困恼，代码很多，不想去找，一定要有耐心，找的过程还可以学到很多知识。

如上图，这个就是我找到的原因所在，unarchiver release掉了，而我们在其它的类中想使用location的属性。

20、MAC 终端（bash）svn命令不识别 command not found   

在mac os 10.8中，svn Command line tools是没有自动安装的，这样的话，svn 命令行就会失效，解决办法：
1.打开xcode偏好设置（comand+，）-->"Download" -->Components:

2.点击“Command line tools”下载，下载完成之后安装。

3.安装完成之后，打开终端，输入“svn help”，如果出现如下所示，说明命令行工具安装好了。

21、ios MapKit  判断坐标是否在MapView显示范围内    

 CLLocationDegrees leftDegrees = mapView.region.center.longitude –(mapView.region.span.longitudeDelta / 2.0);
  CLLocationDegrees rightDegrees = mapView.region.center.longitude +(mapView.region.span.longitudeDelta / 2.0);
  CLLocationDegrees bottomDegrees = mapView.region.center.latitude –(mapView.region.span.latitudeDelta / 2.0);
  CLLocationDegrees topDegrees = self.region.center.latitude +(mapView.region.span.latitudeDelta / 2.0);
  if (leftDegrees > rightDegrees) { // Int'l Date Line in View
  leftDegrees = -180.0 - leftDegrees;
  if (coords.longitude > ) // coords to West of Date Line
  coords.longitude = -180.0 - coords.longitude;
  }
 If (leftDegrees <= coords.longitude && coords.longitude <= rightDegrees && bottomDegrees <= coords.latitude && coords.latitude <= topDegrees) {
 // 坐标在范围内
 }   

22、在App图标上显示数字徽标

IOS7 ： 

  UIApplication *app = [UIApplication sharedApplication];  

  // 应用程序右上角数字
  app.applicationIconBadgeNumber = ;   

上面的代码可以搞定

IOS8:

iOS8中设置application badge value 会抛错：Attempting to badge the application icon but haven't received permission from the user to badge the

原因是因为在ios8中，设置应用的application badge value需要得到用户的许可。使用如下方法咨询用户是否许可应用设置application badge value

UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeBadge categories:nil];

[[UIApplication sharedApplication] registerUserNotificationSettings:settings];

在这之前要判断系统是否为iOS8的系统，否则8之前的系统会报错。

  UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:UIUserNotificationTypeBadge categories:nil];  

  [[UIApplication sharedApplication] registerUserNotificationSettings:settings];  

  UIApplication *app = [UIApplication sharedApplication];
     // 应用程序右上角数字
     app.applicationIconBadgeNumber = ;  

注意：清除数字请将数字设置为 0

1-2设置标签栏按钮显示数字图标

 UIViewController *second=[SecondViewController new];
 UITabBarItem *item=[[UITabBarItem alloc]initWithTitle:@"支付" image:[UIImage imageNamed:@""] selectedImage:[UIImage imageNamed:@""]];
     second.tabBarItem=item;
     item.badgeValue=@"";

效果如图

23、如何获取手机硬件信息？  

通过使用UIDevice：

[[UIDevice currentDevice] systemName];
[[UIDevice currentDevice] systemVersion];//os version
[[UIDevice currentDevice] uniqueIdentifier];
[[UIDevice currentDevice] model];
[[UIDevice currentDevice] name];
真机上结果：
System Name: iPhone OS
System Version: 4.2.1
Unique ID: 9b5ded78d5fa0ac96250f8b4af0e46f40b96ea6d
Model: iPhone
Name: “wwk”的 iPhone
模拟器上结果：
System Name: iPhone OS
System Version: 4.2
Unique ID: 21FFE0FF-429B-5D0B-96D2-EADCA3203260
Model: iPhone Simulator
Name: iPhone Simulator
uniqueIdentifier：iPhone通过，向几个硬件标识符和设备序列号应用内部散列算法，而生成这一标识符。
http://blog.csdn.net/qiwancong/article/details/7914923 参考

24、设置隐藏头部状态栏（电池图标）

1-1 设置状态  如图

1-2添加代码：

 //隐藏状态栏
 [[UIApplication sharedApplication]setStatusBarHidden:YES];

实现效果 如图

25、根据App版本号来判断App开启时是否进入引导页 

实现代码

 #define __kFirstVersion @"kFirstVersion"
  //根据App版本号来判断App开启时是否进入引导页
  - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { 

      //1.获取一个状态:是否已经进入过主界面
  //    BOOL b = [[[NSUserDefaults standardUserDefaults]valueForKey:__kFirst] boolValue];

      //获取到当前的版本
      NSString *key = (NSString *)kCFBundleVersionKey;
      NSString *version = [NSBundle mainBundle].infoDictionary[key]; 

     //获取到之前的版本
     NSString *lastVersion = [[NSUserDefaults standardUserDefaults]valueForKey:__kFirstVersion];

     //2.如果没有进入过主界面,则进入引导页
     //如果两个版本号相同,则进入主界面,否则进入引导页
     if (![lastVersion isEqualToString:version]) {
         ViewController *vc = [[ViewController alloc]init];
         [vc setCallback:^{
             [self startApp];
             [[NSUserDefaults standardUserDefaults]setValue:version forKey:__kFirstVersion];
             [[NSUserDefaults standardUserDefaults]synchronize];
         }];
         self.window.rootViewController = vc;
     }
     //3.如果已经进入过主界面,则直接进入主界面
     else
     {
         [self startApp];
     }
     return YES;
 }

 -(void)startApp
 {
     self.window.rootViewController = [[UINavigationController alloc]initWithRootViewController:[RootViewController new]];
 } 

26、计算文本内容所占空间大小方法

1)对于单行文本数据的显示调用- (CGSize)sizeWithAttributes:(NSDictionary *)attrs;方法来得到文本宽度和高度。

例如：

  //根据文本内容取得文本占用空间大小
 CGSize textSize=[@"Hello World" sizeWithAttributes:@{NSFontAttributeName: [UIFont systemFontOfSize:]}];

2)对于多行文本数据的显示调用- (CGRect)boundingRectWithSize:(CGSize)size options:(NSStringDrawingOptions)options attributes:(NSDictionary *)attributes context:(NSStringDrawingContext *)context ;方法来得到文本宽度和高度；同时注意在此之前需要设置文本控件的numberOfLines属性为0。

 例如：

 //计算多行文本所占空间大小
 CGSize textSize=[@"Hello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello World" boundingRectWithSize:CGSizeMake(, MAXFLOAT)
 options:NSStringDrawingUsesLineFragmentOrigin
 attributes:@{NSFontAttributeName: [UIFont systemFontOfSize:]} context:nil].size; 

27、图解 imagView 的 UIContentMode的显示方式 如下图

 

28、解决view的缩放的时候，layer.border.width（圆角边框）随着view的放大时会出现锯齿化的问题。

   self.layer.allowsEdgeAntialiasing = YES;


29、Xcode 7中http通信出现如下错误：Application Transport Security has blocked a cleartext HTTP (http://)

resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file.

原因：

在iOS9 中，苹果将原http协议改成了https协议，使用 TLS1.2 SSL加密请求数据。

解决方法：

编辑 Info.plist，加入如下设置：NSAppTransportSecurity  ----> NSAllowsArbitraryLoads

如图：

30、报错： You must rebuild it with bitcode enabled (Xcode setting ENABLE_BITCODE)（解决方案）

解决方法有两种：

方法一：使用Enable Bitcode的第三方库

方法二：将工程中的Enable Bitcode设置为NO 如图：

31、Xcode SVN  报错 The server certificate failed to verify. 解决方法

打开终端（实用工具 -->终端），在终端中输入如下命令：
svn ls https://xxxxxxxx/svn/xxxxxx   SVN的路径
然后直接输入 “ p ”  确认，再分别输入电脑密码、svn用户名以及密码;就可以重新连接了。

32、ios修改textField的placeholder的字体颜色、大小 方法

 textField.placeholder = @"username is in here!";
 [textField setValue:[UIColor redColor]forKeyPath:@"_placeholderLabel.textColor"];
 [textField setValue:[UIFont boldSystemFontOfSize:]forKeyPath:@"_placeholderLabel.font"];   

33、iOS获取当前根视图控制器并实现页面跳转的方法

  - (UIViewController*)topViewController
  {
      return [self topViewControllerWithRootViewController:self.window.rootViewController];
  }

  - (UIViewController*)topViewControllerWithRootViewController:(UIViewController*)rootViewController
  {
      if ([rootViewController isKindOfClass:[UITabBarController class]]) {
          UITabBarController *tabBarController = (UITabBarController *)rootViewController;
         return [self topViewControllerWithRootViewController:tabBarController.selectedViewController];
     } else if ([rootViewController isKindOfClass:[UINavigationController class]]) {
         UINavigationController* navigationController = (UINavigationController*)rootViewController;
         return [self topViewControllerWithRootViewController:navigationController.visibleViewController];
     } else if (rootViewController.presentedViewController) {
         UIViewController* presentedViewController = rootViewController.presentedViewController;
         return [self topViewControllerWithRootViewController:presentedViewController];
     } else {
         return rootViewController;
     }
 } 

 //调用
 [[self topViewController] presentViewController:[[TransViewController alloc] init] animated:YES completion:nil]; 

34、全局变量宏定义实现方法

 #define APPDELEGATE ((AppDelegate *)[UIApplication sharedApplication].delegate)

  //用法：在AppDelegate.h中定义变量 通过 APPDELEGATE对象实现全局调用

  //AppDelegate.h 代码
  #import <UIKit/UIKit.h>
  @interface AppDelegate : UIResponder <UIApplicationDelegate>
  @property (strong, nonatomic) UIWindow *window;
  @property (strong,nonatomic) NSString *systemName;
  @end

 //调用方法 (注意得引用头文件 AppDelegate.h)
  APPDELEGATE.systemName=@"KingKong";  

35、解决MJExtension 转换字段为id(关键字)的问题处理

 #import "HGProductModel.h"
 #import "MJExtension.h"
 @implementation HGProductModel  

 //重写 replacedKeyFromPropertyName 方法将id替换为我们定义的字段名
 + (NSDictionary *)replacedKeyFromPropertyName
 {
     return @{@"productID" : @"id"};
 }
 @end  

36、tableviewcell上按钮点击时确定当前所在行的方法

类似这种按钮：

 -(void)btnClicked:(id)sender event:(id)event

 {

 　　NSSet *touches =[event allTouches];

 　　UITouch *touch =[touches anyObject];

 　　CGPoint currentTouchPosition =[touch locationInView:self.tableView];

 　　NSIndexPath *indexPath =[self.tableView indexPathForRowAtPoint:currentTouchPosition];

    UITableViewCell *cell=[self tableView:tableView cellForRowAtIndexPath:indexPath];

 }  

37、设置UItableViewCell 右侧小箭头

  cell.accessoryType=UITableViewCellAccessoryDisclosureIndicator;

38、UILabel 文字显示删除线方法 如图：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAtoAAADWCAYAAADvsyVhAAAMFGlDQ1BJQ0MgUHJvZmlsZQAASImVlwdUk8kWx+crKYSEFoiAlNCbIL1K7x3pYCMkAUKJIRBU7MiigmtBRQQrugqi6FoAWQsidhbB3hdFVFbWxQIWVN6kgD7f2/POm3Pmyy937r3zn8nMlxkAFO1ZAkE2qgRADj9fGB3ow0xMSmaS/gAEIA8Q4AZ0WOw8gXdUVBj4xzJ8C3rCct1SnOuf/f5rUeZw89gAIFGQUzl57BzIRwHANdkCYT4AhC5oN5iTLxDzO8iqQigQACJZzOlS1hJzqpStJT6x0b6Q/QAgU1ksYToACuL8zAJ2OsyjIIBszefw+JB3QPZgZ7A4kHsgT8rJmQ1ZkQrZNPW7POn/ljN1PCeLlT7O0rFICtmPlyfIZs37P6fjf5ecbNFYH/qwUjOEQdHiMcN5q82aHSpmqB05wU+NiISsAvkijyPxF/O9DFFQnMx/gJ3nC+cMMABAAYflFwoZziXKEGXFecvYliWUxEJ/NIKXHxwr41Th7GhZfrSAm+cfM8YZ3OAwWc4V/OyIMd6WxgsIhgxXGnq0MCM2QaoTbS/gxUdAVoDclZcVEyrzf1SY4Rsx5iMURYs1G0J+lyYMiJb6YOo5eWPjwqzYLIkGdche+RmxQdJYLJGblxg2po3D9fOXasA4XH6cTDMGV5dPtCy2RJAdJfPHtnGzA6Ol84wdyiuIGYu9lg8XmHQesCeZrJAoqX5sWJAfFSvVhuMgDPgCP8AEIlhTwWyQCXidA00D8Ju0JQCwgBCkAy6wlFnGIhIkLXz4jAGF4C9IXJA3HucjaeWCAmj/Mm6VPi1BmqS1QBKRBZ5BzsE1cQ/cDQ+DTy9YbXFn3GUsjqk41ivRn+hHDCIGEM3GdbCh6mxYhYD3n7ZvkYRnhG7CE8JNQg/hLgiFrVw4ZrFC/vjI4sFTSRbZ91m8IuEPypkgHPTAuADZ6FJhdP+YD24MVTvgPrg71A+14wxcE1ji9nAk3rgnHJsDtH6vUDSu4ttc/tifWN/3Y5TZFcwVHGQqUsf1+457/ZjF97s54sDP0B89sRXYEewCdga7hJ3AmgATO401Yx3YSTGPr4SnkpUw1lu0RFsWzMMb87Gut+63/vwfvbNkCoSS3xvkc+fmizeE72zBPCEvPSOf6Q3fyFxmMJ9tNYlpa23jAID4/S59fbxlSN7bCOPyN1tuKwAupdCY/s3GMgDg+DMA6MPfbAZv4PZaC8DJLrZIWCC14eIHAVCAItwZGkAHGABTOCZb4Aj/R7yAPwgBkSAWJIGZcNYzQA5UPQcsAEtBCSgDa8FGUAW2g12gFhwAh0ETOAHOgPPgCugCN8F9uDb6wEswCIbBCIIgJISG0BENRBcxQiwQW8QZ8UD8kTAkGklCUpB0hI+IkAXIMqQMKUeqkJ1IHfIrchw5g1xCupG7yGOkH3mDfEIxlIqqotqoMToZdUa90VA0Fp2BpqO5aCFajK5GK9EadD/aiJ5Br6A30R70JTqEAUweY2B6mCXmjPlikVgyloYJsUVYKVaB1WANWAv8ra9jPdgA9hEn4nSciVvC9RmEx+FsPBdfhK/Cq/BavBFvx6/jj/FB/CuBRtAiWBBcCcGEREI6YQ6hhFBB2EM4RjgHd1QfYZhIJDKIJkQnuDeTiJnE+cRVxK3Eg8RWYjexlzhEIpE0SBYkd1IkiUXKJ5WQNpP2k06TrpH6SB/I8mRdsi05gJxM5pOLyBXkfeRT5Gvk5+QROSU5IzlXuUg5jtw8uTVyu+Va5K7K9cmNUJQpJhR3Siwlk7KUUklpoJyjPKC8lZeX15d3kZ8qz5NfIl8pf0j+ovxj+Y9UFao51Zc6nSqirqbupbZS71Lf0mg0Y5oXLZmWT1tNq6OdpT2ifVCgK1gpBCtwFBYrVCs0KlxTeKUop2ik6K04U7FQsULxiOJVxQElOSVjJV8lltIipWql40q3lYaU6co2ypHKOcqrlPcpX1J+oUJSMVbxV+GoFKvsUjmr0kvH6AZ0Xzqbvoy+m36O3qdKVDVRDVbNVC1TPaDaqTqopqJmrxavNletWu2kWg8DYxgzghnZjDWMw4xbjE8TtCd4T+BOWDmhYcK1Ce/VJ6p7qXPVS9UPqt9U/6TB1PDXyNJYp9Gk8VAT1zTXnKo5R3Ob5jnNgYmqE90msieWTjw88Z4WqmWuFa01X2uXVofWkLaOdqC2QHuz9lntAR2GjpdOps4GnVM6/bp0XQ9dnu4G3dO6fzLVmN7MbGYls505qKelF6Qn0tup16k3om+iH6dfpH9Q/6EBxcDZIM1gg0GbwaChrmG44QLDesN7RnJGzkYZRpuMLhi9NzYxTjBebtxk/MJE3STYpNCk3uSBKc3U0zTXtMb0hhnRzNksy2yrWZc5au5gnmFebX7VArVwtOBZbLXonkSY5DKJP6lm0m1LqqW3ZYFlveVjK4ZVmFWRVZPVq8mGk5Mnr5t8YfJXawfrbOvd1vdtVGxCbIpsWmze2Jrbsm2rbW/Y0ewC7BbbNdu9trew59pvs7/jQHcId1ju0ObwxdHJUejY4NjvZOiU4rTF6bazqnOU8yrniy4EFx+XxS4nXD66Orrmux52/dvN0i3LbZ/biykmU7hTdk/pddd3Z7nvdO/xYHqkeOzw6PHU82R51ng+8TLw4njt8Xrubead6b3f+5WPtY/Q55jPe19X34W+rX6YX6BfqV+nv4p/nH+V/6MA/YD0gPqAwUCHwPmBrUGEoNCgdUG3g7WD2cF1wYMhTiELQ9pDqaExoVWhT8LMw4RhLeFoeEj4+vAHEUYR/IimSBAZHLk+8mGUSVRu1G9TiVOjplZPfRZtE70g+kIMPWZWzL6Y4Vif2DWx9+NM40RxbfGK8dPj6+LfJ/gllCf0JE5OXJh4JUkziZfUnExKjk/ekzw0zX/axml90x2ml0y/NcNkxtwZl2ZqzsyeeXKW4izWrCMphJSElH0pn1mRrBrWUGpw6pbUQbYvexP7JceLs4HTz3XnlnOfp7mnlae9SHdPX5/en+GZUZExwPPlVfFeZwZlbs98nxWZtTdrNDsh+2AOOScl5zhfhZ/Fb5+tM3vu7G6BhaBE0JPrmrsxd1AYKtyTh+TNyGvOV4VHnQ6Rqegn0eMCj4Lqgg9z4uccmas8lz+3Y575vJXznhcGFP4yH5/Pnt+2QG/B0gWPF3ov3LkIWZS6qG2xweLixX1LApfULqUszVr6e5F1UXnRu2UJy1qKtYuXFPf+FPhTfYlCibDk9nK35dtX4Ct4KzpX2q3cvPJrKaf0cpl1WUXZ51XsVZd/tvm58ufR1WmrO9c4rtm2lriWv/bWOs91teXK5YXlvevD1zduYG4o3fBu46yNlyrsK7ZvomwSbeqpDKts3my4ee3mz1UZVTerfaoPbtHasnLL+62crde2eW1r2K69vWz7px28HXd2Bu5srDGuqdhF3FWw69nu+N0XfnH+pW6P5p6yPV/28vf21EbXttc51dXt09q3ph6tF9X375++v+uA34HmBsuGnQcZB8sOgUOiQ3/+mvLrrcOhh9uOOB9pOGp0dMsx+rHSRqRxXuNgU0ZTT3NSc/fxkONtLW4tx36z+m3vCb0T1SfVTq45RTlVfGr0dOHpoVZB68CZ9DO9bbPa7p9NPHujfWp757nQcxfPB5w/e8H7wumL7hdPXHK9dPyy8+WmK45XGjscOo797vD7sU7HzsarTlebu1y6WrqndJ+65nntzHW/6+dvBN+4cjPiZvetuFt3bk+/3XOHc+fF3ey7r+8V3Bu5v+QB4UHpQ6WHFY+0HtX8YfbHwR7HnpOP/R53PIl5cr+X3fvyad7Tz33Fz2jPKp7rPq97YfviRH9Af9ef0/7seyl4OTJQ8pfyX1temb46+rfX3x2DiYN9r4WvR9+seqvxdu87+3dtQ1FDj4Zzhkfel37Q+FD70fnjhU8Jn56PzPlM+lz5xexLy9fQrw9Gc0ZHBSwhS3IUwGBF09IAeLMXAFoSPDvAexxFQXr/khREemeUEPgnlt7RJMURgL1eAMQtASAMnlG2wWoEmQo/xcfvWC+A2tmNV1nJS7OzleaiwlsM4cPo6FttAEgtAHwRjo6ObB0d/bIbir0LQGuu9N4nLkR4xt9hJqbODgr4sfwLlCNrSd36L+cAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAJvaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA1LjQuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOnRpZmY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvIj4KICAgICAgICAgPHRpZmY6WFJlc29sdXRpb24+MTQ0PC90aWZmOlhSZXNvbHV0aW9uPgogICAgICAgICA8dGlmZjpZUmVzb2x1dGlvbj4xNDQ8L3RpZmY6WVJlc29sdXRpb24+CiAgICAgICAgIDx0aWZmOlJlc29sdXRpb25Vbml0PjI8L3RpZmY6UmVzb2x1dGlvblVuaXQ+CiAgICAgICAgIDx0aWZmOkNvbXByZXNzaW9uPjE8L3RpZmY6Q29tcHJlc3Npb24+CiAgICAgICAgIDx0aWZmOk9yaWVudGF0aW9uPjE8L3RpZmY6T3JpZW50YXRpb24+CiAgICAgICAgIDx0aWZmOlBob3RvbWV0cmljSW50ZXJwcmV0YXRpb24+MjwvdGlmZjpQaG90b21ldHJpY0ludGVycHJldGF0aW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KzyLdDAAAQABJREFUeAHtnQeYJFXVhs/szpKjBAmCS0YkowIqsIKsINGAOWBGxYjob0Axi6JiwixBEBEDBoKKuAqikhUkSVIkLDmH3WX7P2/VnJ471VUdprt3pne+8zw1VV1169att2tmvnvq3HOHam4mEwEREAEREAEREAEREAER6CmBaT2tTZWJgAiIgAiIgAiIgAiIgAhkBCS09SCIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAhLafYCqKkVABERABERABERABERAQlvPgAiIgAiIgAiIgAiIgAj0gYCEdh+gqkoREAEREAEREAEREAERkNDWMyACIiACIiACIiACIiACfSAgod0HqKpSBERABERABERABERABCS09QyIgAiIgAiIgAiIgAiIQB8ISGj3AaqqFAEREAEREAEREAEREAEJbT0DIiACIiACIiACIiACItAHAsN9qHNKVXn22Wfbn//8Z7vqqqvsyCOPtCc96UmL7P5vueUWu+iii7LrPfOZz7RVVlmlq2tfffXVds0112R1PP/5z7fp06d3VN/ChQuNBRse7t2j9cgjj9jSSy/dUVtUWAREQAREQAREQAQmmoA82l1+AzfffLN9/OMft5NPPtm+/e1vd1lb+ek33HCD/fa3v7WbbrrJarVavRACf999982Wyy+/vL5/vBsnnnhivT7EbZWdccYZdtppp1nxmocccojNmDHDVlxxxapTW+5/7LHH7Lzzzss6LS984QttjTXWsF133bXleSogAiIgAiIgAiJQQcAdc3bbbRUHtbufBHrnduxnKydx3a94xSvsU5/6VOYJ/t73vmcf/ehHM7HZyyZ/5zvfsc997nM2NDRk99xzT1dCthftQgA/+uij9ta3vtWOPvrojqpEwN95553Zctddd9W3b7zxRvvrX/+aeegR26nNnTvXTjnlFDvggAPS3doWAREQAREQgf4RmDfPzB1LPbMlljDbc8+eVVdaEW+V//c/89fsZhdcMLogtGfNMvvjH0tP087+EZDQ7pIt4RWI61e96lXeWbzNfv7zn9tLX/rSLmsde/rvfve7bMemm27atci+//77s/AOPM/LLrvs2Av18dOzn/1su/jii62Zp7x4+dVXX9223377bFlvvfWKh/VZBERABERABPpHwP9f2v77967+lVc2u/vu8dW3YEF+rjuosjpiffvtZv7WO1uuv97sP/8xo4NQNEJB3VHnXkGzjTcuHtXnPhIoFdrEG//4xz+2f//733bttdfa9f7lEf+7ySabZMtee+1lu+yyS8tmEe5wOw9BE8NL++QnP9m23HLLliLyD3/4gxGXjG200Ua2ww47NKm5+hDe03POOScrgFDGKx32gQ98wC688ML42Nb68ccfr5d773vfa3igO7GnPe1pdsQRR5Segvf3kksuyY4hOrs1rsX3+uIXvzjzEndbX7vn33rrraUie9q0abbaaqtlISKEidCZ4HvlXiWu26WrciIgAiIgAn0l8MpXmi21VOMlHnrIXDDl+1/2MnMPVmMZ/z9uv/xl4/7intmzzf7731woI5Z5u8s6tpPQ0eKpYz4zRsp1lW22mdmOO5r/UzV7+tPNlltuTLFxf0DQ/+1vuWj3N8624YZmT31q7jEvY9TsQvfeax4vanbuuQzuMttpp7zNnbYVNv/6V14P6623zuvqtFPRq3rSe/aY37p5LHDtta99bc3Fp7fYmi7Pe97zaj4Qr35u2caznvWspnUUrzFz5szaxz72sdq8efPKqqt5+ES9vqc85SmlZdrZ+fa3v71ez+zZs8ecwudiu/r9udiGtEEnnXRSvT2rrrpqzYVofVlrrbXqx9Zdd936/rTMFltskVZX8w5Kdo4L7TH7+XDYYYfV63vggQcajseOpZZaKivnoSOxK1u/+93vzvYvs8wyY/bzYf3118+O7b///jWP8a5556Hm4ru2YMGChrLaIQIiIAIiIAITTuCOO5Bd+cJ2md1002gZtsvswgvzMiuvXHZ0dN9BB43WFddN1zNm1GquA/wfaq225ZajZV/3ulrtG9+o1c48s1a79tpabf780Tp7uTV3bq1GG4eHR6+dts91SO3EE2u1hQtbX5X//W96U602bVpjXdT/wQ+2riNKnH9+rbbmmo310LYNNqjVrr46SjZf96qewlW8+5DbP//5T+/47GgPP/xw7KqvV1ppJYuQg9iJt/r3v/+9nXrqqbbPPvvE7q7WeJoZWEj4xTHHHGPbbbfdmPpe6T3KD33oQ1now5VXXmmXXnqpd1q819KBubCzn/zkJ/UzXvOa19S30w08+GTe6KedfvrpRpxyM0u94xHbXFb+v/SCS4wQkclkm2++ue2xxx6TqUlqiwiIgAiIgAhMPAEf72UHHWQ+0Ctf8PCyTWz38subp98abeODD+b72OOJCDKP8ujR3m898IDZzjubeXayzPA448Um25m/Jc8WdAief+LDP/GJ6jbgqcf77/oxM49ssK22Mps/P/dKEybz2c+aCySzb37TzN98V5pHOmThPfDAXK9m3mwystHm664z89BVzyhhts02eZmyn72qp6TuTGjf7TFD7mmsi+wl/Et1z7a95S1v8VCejf37Xd7fXMzzEKAb7Pjjj88GwN3r7n5SuRF2ca67/LcCUhNjIFtZqAdCk1AG0tQRooJddtlltttuu9kVV1xh7rWt10rqPDJQnHXWWdm+H/3oRx0Lbc694447svO5rxe84AX1+tMNwha4137a0/1VTjOhTWfjjyMDF2BH+dRIxUeHB2OA4tprr50ezrY7TdHXUIF2iIAIiIAIiMBUJ3DCCaPCNmWRxlyfdJLZE56QHs233YnYliFaWSajvfnNoyL7He8w++QnzeN9R1tKOO7rXpcLWzoM6JUqJyx1hchGg5FUwUNHM2Mg54EHmiF8CcNddVWzT3969DrpFoIehyihNXRCcKIy2JR4dET7z35m9upXm4u+PKwF0U19RetVPcV64zMe7je5+94/ZwthAZ79oeD4HvuREBMXdfVz3Ks8tsDIpzR0xFPflZaJnfP9VcfXvva12gorrFCvlzCDov3whz+sH19nnXX8DUUbryiSStyDXT//dbxuKViEjngsc+FI7z9yDbiXhY74wMrayv6aieOs+Vy0NKxkzpw5xcOlnyc6dOQjH/lIabu0UwREQAREQAQmFYE0dIQwhG6XVqEjndw84Z3Rnssv7+TMzsvCYWgov94BB1Sff+mlo2El++1XXu6WW2o1QmBo+0471WqPPNJY7r77arWttsrLwOzhhxvLsOfgg/MyHu5c+9Wvyssce2xehut99rPlZXpVT3nttcyj7SLN9Vxun/nMZ0o9z3GctcdSZ+EXLqSz3YRw/M97Id1M1sIEJwcffLC5qMwyeFAxYSlk3HAhml2HH3igl/NXFg/6awLySuNN34ng+TaMjBe/+MUv6iWrwkbqBSZwwzsdWSo/mvCFL3zBnvjEJ05ga3RpERABERABEZjCBA49tHyg4333mX35yzmY97xnrJc3cJHEocMkCXHqpFj/6U+5pKcxb3tbdZOIbNhiC/MMDvmgxLKSzDeCtxn7ylfKB5iusIJ5hgjzONM8U4pHL9gb3pCfEz8JCznuuPyTJ+io9J57dIZ961v54E3WfI94vMN6VU/UV7IejtCNONZu/CwzEW7mI1oJ78DOPPNMe+Mb3xjVjHtNHPa3HAYCGmNSllRok5KOjBnHHntsdpzwkXaF9m9+8xsP2fEvx41MJ+1kTskKT8CPww8/3LtfNR/Y+zd7/etfPwEtaH1J0vV9ljiqETv//POzLX87Ud//rne9y3xwZBTRWgREQAREQAQGj8D7318edkCoQwhtzzrmHsfGeyNeuBOhfdRRrdMAEi4R9vWvm6fvik/la+K8P/KR8mOt9jIWLvKJjzhYK08JpyBx1kUjQ1twIBtIs5hpDx/OwmiI0ya0pCi0CeUZ0XNZvHfxWulnUi6TJYXUhz42bowo71U96fUK28N4hVPrZBpv4qoRVRhx3b0yPOUhtBmkWTQ80SG0f/rTnxre33am/EaUh73a43ZILdjKvvvd73qYj8f59NDoOJAG0MNkPJzrCVkMfLF67ufTHpfE4M122lk8f1F8/vvf/24sReOZYNAqRucrFdoIczz0nZhnmKmnOOzkPJUVAREQAREQgYEjgHAmnrhdw1Pbyhi82Exoc+xXv8pjmvH6prbBBmYsrYzJckbSEZcOzvQ0v8aCtZqAjoGg++1n9oMfmGe+MBdDefq//GzzgX351pJLmk9pHXvL1y96kRlvGzDSN6ex472qJ6+99OfwhuQ/TIxQDSZfacc8ntvTSi7VTtGOypBLOaw4zTf7Z82aZZ7OztNN/jebWZA2t8oQwuBNpg4PqwobYRpyZiaMjsPVPsI2BhzGud2uY4AnecGr7CHPzcmA0GaWDqRklkaEe5XRcWmnM1J1fq/2k3M8zTveTr0MxJWJgAiIgAiIwIQRQHyW6R3yaIfhYCrLoz2SgCGKtb1mYB/5sMsMJ+f3v58fwWPLZDhlxlwmnsmtqc2ZMzrgEM/93nubuYOrY+MNN3m1sXe+M1+nP/H+h7WT3zrKIOAR6OusE2fns1/yiYQZZcxHS+bn8d35jNbZrJnpsWhTt/WkdRa2h4l39hzH9Ywf7/DRpHwmNGSiLMI7uH6ZeMTDi0cajy+Gp7qV0CZlYEztTRpDJrwpM89VPWY3WVd23333MfuKH5iOPCbAoePSaqKVp5ISp4UhRsu8xVWnke6wmZEhptfmg0nt85//fNNqi29InvOc52TsI20hEwStmI5cTmqjDCkfmdBGJgIiIAIiIAITRmAkXLXp9X/4w6aHOz5IPDSit8xIZxdC+7DDqtP7MQ17K6E9Y8boFXjTjze5XaOjQQixRxYYYRiYZ6yzl7wk305/hqhln8/83NLSMjffXC600zLNKqQc6QepJ7VoU7f1pHUWtjOan/Q0LcRGY3h+mS6bacSJDUYYLWpPaOrFrkobiEc6hPYvfcYl8n+nIQqF+8zEeOyr8mbH8XT9Zk9Dw9LMCL/Bw47B7IMf/GCz4m0dI/81KRabGekWiWHHfAKhbHbFqvL9SPPH24xix6Tq+rGfsKBD3TPwff8DQWeCGSDLUiwSMuMTFGWn8QzKREAEREAERGCREuAt8a9/3fySzPpIWjvMU/KWpo/Lj+Y5sWN7Mq2Ju8YbHaEjFY7IepNJKuEphRuM2avx/BOqUWapyI1Y7rJysS8VvyGI41jU1U49nBNCu1/1RLtK1pnQJhc22TiId8YYhMcU7CxkASGm+LnPfW7m2WUQYT+NnN6/4ssesaoJafA0I9Lw+pKB5Nf+y0DnoMw8NV49H/WSHs9TVa7s3Inat7TnhIw49Ko28P2E0EbcL6rBnRGXP17xzlsKJiNi8CRhP2VC+0KPo2KSJKxVCE0VH+0XAREQAREQgXETYOxZlUc5Kk2Fm+uk0sGQUXYyr//v/8xY2jES5pUZLHwiQ3+tb7btto0l0gn6Kt5kjzkpDYelQxPGoEqmbsfaqYdyUVc/6qH+JjYtjjFb4lc81Uox5vqee+6xk08+2TzXts2cOTObNIXBbP9h9GaPDS8mscYIY4ywFiZiqbLU45sOdCyWp/0ROsEslnQeOjHitJlUJ+ro5NzFrSwiO2KsI459PPcYXmpmFy2zmJSILDN0qGQiIAIiIAIiIAKTgAAplRljxkIWD7KCHHigGfHgpO/z8FzzRBINlnqo04l+GgqO7HD9Wbf0XNLzxcQ+7dRDJVFXP+qpN7J8oy60iXt+pwevX+cjXY888kjvjJT0RrwOPI3v92B54pAP8qlCw+tYXn17e2/3L4fwjy233HLM9OhHeB7FZh50PNMh9kgvSKegzFIR3knYSNT1Hh+tigd9g3ZG3cZJi+maXORhwT4+N1tHJyW84CG0ed5iRtD0/BgoSurGyTaNfNpObYuACIiACCxGBIh9ZuBcu0uqC9hu9zzKca1BNMZN+Szd2cKATXeQZmEzzLBI1AMJDIgvL44dS1MfIspbWVqmOPN11JWWaVZflOtXPU2unYWOpMfJiHHIIYdkCyIIwcPCVOAxdTnlCS/x2R69M3N6FupRFeIRdX/4wx/2/ONHxMf6mswZ95HwvWAMbsS73cxIjYeHmvR7ZKZgXczlzT1EfmcG1e3JQ9GB4WWPgY4xQU8Hp3dd9Oyzz7ZTTjmltJ5rr722vv9LX/pSFupT35FskMs6zeSSHOp4MxXapD5MJwBKK/MZIMdkr4nvOAY+Mg4AAY2HnPAROm1hxNufd9552UeFjQQVrUVABERABBYJAc88Ni6b6hmyPJGGMQ09yTRIx4fmSweRpiI3hG8z0Gm2lvRczuHzP/6Re9Gb1RHHoq5+1RPXKVk3CO20DB5cFgYD4pFEcBJicowH/IfgYiAg6QCZvKSZh/NOj4thaWXLL798NggOkd1O/mg81JHnGs91UWj7NOX1SxKL3unATjz4xIBjrbKP1C/Uw43LLrssm8CnVZVpXHux7It8YEI/hDadpDTFYHrd9O0CnbJ487HSSitlxQgJecYznmF/+ctffHKn48YIbZ6vSOknoZ1S1bYIiIAIiEBfCZBvup1wBH/zbz6TtrkjK5vhkEZ5Fq1MXH70o2bvfnfrZnKtxc0IGyGsg3js4jwo4YXmnv/1r9Z3HmWmefDFmmuOLR91Mesm8doj2mJsoZFPOCWjExTnRcH43G09UV/JuqnQTstP8xtlsB3L+973Pg/HObA+EO9fDuOrX/1qtj89J90m9rssBAAxTRgKYSNkGHmJp4RZJ82VmFZSso2HGk813vY/+TShtzisyFNN8W7DRvDkhzEgtJV94hOfaJnyLuqg7lZvAqIsa2biTDsKZIghlzhGSkZi2sPwCqce79jf7ZprhuHhT1MZ0iE59dRT43B9zf6I6w6hzUFm+ERoM/slHmxSSiKw480H99sJn/oFtSECIiACIiAC4yXQahwXXlqydDBRikcA1IX2wQfnsw96JjdPRdY4m+F42zPR5/kb80zM+v/klrMw0tYQ2oleyG5hjTUQK+bxouav6s3FkrlHtfzueKsQGV+e/vSx06ZzBl5zZpkknzhZUCLzS1ltaVTADjuMLdGresbWOvaTexvHZS64ai6yGHqaLe41bajHhVj9uIeZNBzv1Q6PLa9fx0Mo6tVeeuml9f2bb755fX8nG+51zerw2QkrT3OxW79O8GhnfcEFF1TWGQeOOuqoet0eyx67s7V76+vH5syZM+aYi9f6MR9wWD/m+cOz/S5y6/ti47DDDquf47nMY/eYtWd3qZfxiXzGHPN0g/Vj3vGqH/OBs/X9HgpT3+8CvObhP9kxH/Sa7fdwlHpZf3tSL6sNERABERABEZhwAmiM6dNrtfXXr9XuvrtWu+kmcnDkC9v879xqq1pt2rRa7ROfqNUWLuy8yRtskNfn/28rjevEdS+/vLJY7fzz83LLLVddptWR/fbL61hjjdb3c9ddtdrQUF7+5S9vrPkLXxht93nnNR6PPaeeOlru+ONj7+j6kUdqtVVWycvMnj26v2xr663zcnAtfh+9qqfsuiP72vZoj5XnZFRZMQsZIQc3hld7oozwETzqGB5sBi/GdrbhP8YzCJKwjYjvbjdshEF+7cZyp573aOdkX98cuSu9oU+KVy4tGp0Odlwzef1D+MjB7gHgLQCecLK7MEU7xhsOPN4yERABERABEZhwAoSQvvGN5mnYzLMj5Bk38HynM0PSSN4s8yZ8jz3MCCHxFMTGRDatvOT9ukG8xxhTlTczHw9mv/lNPtFM0evLLNWesMJTwpmh+bivKnv723P5z/GyOTB8rpHsfBIrMDaLuUCKKfq4TkyZzsDLsslvGEzK90EcuI/zygZjlnm18ZozhTvGAM2iB71X9eRXKP05/N73vtfDke7ODr7NG0HcbLuWCi3yPk+UkZOZ2RYR+8RUk4qPGRrJM42R6SIm5OmkjUyqEtYs/jzKsEaQ92LCmrTOybT9vyRnaLshPghojNChYuYWZiIlyw2hLgxsDVF++OGHtxWjP5nYqC0iIAIiIAKLIQHmGPGQWc9rjBcozxWdpokr3jKi+qyz8tCS004zHySVh0m4U7BB6BXP7cXnl788HyRIbPNIYgGfkKK6ZtdMPllKLpBJ1cf/+XSWbMQx6frc+Wgf+1g+wyIT80XGFfzFDEz0pBdZuj+uRH2cVzRPYpHNHHnUUXkMN+E3xLu7jsveC9AxIQTHJ+TLDMFd1UkgYca3vmWeUcN8MKH59N9mBxyQh64g1ungRG5wJrYpaw8X6VU9eYsbfk671eePZzAaS3iFG0pV7IjMEBzuRKBXVNfV7tRjzQBIYn8jfpnY6k69x0zX/sNkOlVyjP+DB2mKWzAl4wsDV9uxENp0fopx+swsGQNY6SBhpJYsm8SmnWupjAiIgAiIgAj0hIBPqmazZuXiDZHNDNp4YJuJ7Lgw/x/xtHo6ZB9ElueZ9mxbmYc7yvRrzbXxUCP23YmVedMPPLD6apdfPuqFRqyO/C+un+BvnzOPdtw3Tkj/f57VS9w219tmm1GRvfnm5p7OxrjqqPCLXzTD843BEwcvdSPumaXykkvyY0wt32ymbVIJ+tg8nxY7z3KCYKYeJszxDHoZezoBfD733OoBk72qJ291w89ppNELY2bIyF8c+6rWlziIyPZBmYkW2nisGbCJET5ybJJSJhXhWYE2fnzHg+zD08/U7qShox6PXW7j7MW3CNllMEI72rXL+SV28zj30lMIH0nNY8XTj9oWAREQAREQgUVDgLR0DJ5D8DFZGkIODzXC8YQTGsMcmrXK3+JmoQ0+z4fhUcW7TFgG3uWKydqy6gjNcOeev6pvVnv1MQZouvM0W/Co491tltqY2S9pExqKkE0yhxQNsXrNNbnXGuGNMdiRXNkRPkOYx9e/ngvlmFAmLzn2J9eh3Kc+Neo5J0tJDJ6EFcc9rLSleRIN96zmXJnIxjPk2Y035h2H4eG8o8RxOgbNrFf1lFxjeG8HTAgIIQF4cXl9/3W/wVe/+tUN3sc4/4wzznAP/Ovrae/W9dG1++23XxyekPXanhsRzzU5mfGghhcVr2un3lFS03384x/P7gNPOJ0PYq//6alq9t9//yx3OFO5D6KRBpDvOc3+0e59kD3kiiuuyIpvQ++1DSOLCG8XsDJxTlveXUiD9IMf/MBnvd17TIaVNi6lIiIgAiIgAiLQHYFvfGM0NR/C7bWvzeOS8ZCO12bPNsPhRGjF976Xe5vxOH/ta3mYRLFeQky6sU02MWNp1+gQ4P3GkYh3usqIpUYcE46BwMbzzbitmTNJi5bHrlNXuwYPFia6QScgjOngtBLFxfrJZPLXv+bt9yxmWepAhDOe8ugUFM8p+9yregp1DzMd+Wne42ECEby15Md+wxveYEw4wmA00sYhpBGfpItDyIZXk7pI2/fzn//cs7msUqh60X/E40z7UjvA43U6jR9ngGfkh2agHjmoGaw3a9Ysfxtztnf8dvOc7Cd1lIYwbdOi2I72F6/VTT5t4t9jhsd2hTYim/hrbDZ/bBJ79NFHs04Qs3qm5plN/G/ba7PQnXhLkR7XtgiIgAiIgAj0hQDhB8Qj403Go9qJYG3WIMIimJ6c+n0W7sySidqanbrIjjUT2WkjGPBJyj2WXhgx7CzdGu33cXLZ0k1dvapnpA3efcg9jYSNMPFMzP5I7PbX6G01MeJrj/bAeQYjTgbDc40HOw3v6DRshDCHb9CjdfOUgHbggQdm29v7KyQmUoER4pGc3//nvTom85kshhefCYTwPEcuatq2esRVddlQ8pSHtTuRTHR8iOmGYRjim+8rjjPFPSE/TCp0jb+eYpvMNjxfMhEQAREQARFYJASWWMI8q0I+lXo7FySLRbzhLma0KDt/663zuGQcUHhwZYs9gWlxh3gbPQ9yNtkKE8A0M7zgn/LXB5THYzxZjFjqNCXcTH+dsfPOO7fdPCZj8XzO9VkJP+9pYchYEvayl70sm1wFAY6H/wM+CxRhN4TRhIXHNz4vyjVCm6wnCFgmgcEIfdmkzR75bcRxNbETiE9zw5vdzuBS4tqPP/747Byer/BOn+uDEuiohMgmYwwing4bYTp8b9g3v/lN22uvvfzNlL+akomACIiACIjAoiBAyrd2jSm9/e1sthSn925Wh+uVrgyvMjHNLBXjn7qqXyf3jMCY7hR5jQ899FAj5dpVHjNz3XXXZeEieLcRlDElu0960lY4BoJqURvxvSydGgIZb3VkvkA8M+tk0Z72tKfZRRddlHU0Pve5z/kYgIc8tMljm0aMkJsv+ohahGgseNkJX6EjwJpwG2KX8eoSqsOa5UMf+lAWqhN1dbomtIWOQczCyOBDnwDGO9uj8eSIX+KsaUe0ifb83VPqxKyOtDOdZZJ2kGEmZprcl3Q8bRiDZZmpE2PGT+71wx6PRQaX6JAw86NPqOODjf21mhvPGWJ7p512ys49/fTTs9SNpACM7CRZQf0QAREQAREQgalMoJh/eiqzmMz33mQymyl1yAWd54DJZ7ncYYcdaj5Ir+X9e1aSmntsaz5AsuZCsX5+1NPpmvqK5qK45qkXs8VjmsccLpsZ0r2/NWaqrJrZccGCBTUX0U3b6l7xMdfhg4vfmgvymk8B7xNh+exXJeZvOOr1MjOkx/pnnz3Ov+biv+adl/px2HD8vvvuK6mpVqMuH4A6prznNS8tq50iIAIiIAIiIAIiMBkJjPFou/iZsob3+qUvfamdc8452eDOdiaoIYSG7CwsGJ5/MpPgMWbbp0y3uXPnZms833ixybLBmiW8upxL1hTqKxpe6aq0eMWyfG4V0oHHm1hpvMZlxrXK8qnvuuuuWajHyT4rFl7nduzLX/5ylnscPoSN8KaEOHcmusHTXhwcmdZJ+Aht/LYPHnm/5yElXpvQHZkIiIAIiIAIiIAIDAoBn5CebN4yCBC+QegI8cODYMRhx2BBwk7azShypaflYdBkakNDQ5mAJizIvdbpoba377//fiP/OMZgSWK5yX5C6EqEojAJECkS253shrr+4xMFMB6A0BiZCIiACIiACIiACAwKAQntQfmm1E4REAEREAEREAEREIGBIjBtoFqrxoqACIiACIiACIiACIjAgBCQ0B6QL0rNFAEREAEREAEREAERGCwCEtqD9X2ptSIgAiIgAiIgAiIgAgNCQEJ7QL4oNVMEREAEREAEREAERGCwCEhoD9b3pdaKgAiIgAiIgAiIgAgMCAEJ7QH5otRMERABERABERABERCBwSIgoT1Y35daKwIiIAIiIAIiIAIiMCAEJLQH5ItSM0VABERABERABERABAaLgIT2YH1faq0IiIAIiIAIiIAIiMCAEJDQHpAvSs0UAREQAREQAREQAREYLAIS2oP1fam1IiACIiACIiACIiACA0JAQntAvig1UwREQAREQAREQAREYLAISGgP1vel1oqACIiACIiACIiACAwIAQntAfmi1EwREAEREAEREAEREIHBIiChPVjfl1orAiIgAiIgAiIgAiIwIASGB6SdaqYIiIAIiIAIiIAIVBKo1WqVx9IDQ0ND6Udti0BfCUho9xWvKhcBERABERABEegbgccft9p5fzabe6vVllveahtsZLV1ZpoNN8qbENjFdbQt9sdnrUWgFwQan8Re1Ko6REAEREAEREAERKCfBK6/1mrveJ0N3Xh9dpXwU9dcZNeevL4tXG/DTHgvXH8jMxfgtu56mQBHUMfCiSGwi+toeuyPz1qLQCcEhvxVS3vvWjqpVWVFQAREQAREQAREoF8EHn3Eavs+x4ZuvqntK9SmD9vCdWfWxXcNAb7hxuMS4JNZfD/00EN22WWX2cYbb2xPeMITSvnMmzfP/v73v9vChQttm222sRVWWKG0nHZ2T0Ae7e4ZqgYREAEREAEREIFFSKB2zh87Etk0bejxBTb9hmvNWOyMemvHCHD3gi/cwMU3ApwQlAfus6FVVqt7wENgs06365WNbFxxxRV25513Fnf35PMznvEMW2qppSrruv766+2mm24yxPTOO+9cWu4f//iH3Xbbbdmxf/7zn/bsZz+7tJx2dk9AQrt7hqpBBERABERABERgURK4+oqeXW2sAB+tNhPg66zrHvCNbd7HjrChZZa1adOmZQI71lVi+7777rO5c+eOVtbDrcc9Lr3K8FDfcMMN2eENNtigtBjtuvHGG2355Ze3ZZdd1m699dasrU984hNLy7ezk+CIBx980JZYYglbcskl2zmltAydA5ZlllkmY11aqI2djzzyiM2YMcND9ccvc3tRB00dfwvauFEVEQEREAEREAEREIFeEkDU1dZY0yImu5d1p3VlApz4b18WLnjcHvnsVzLxN3369GyN2I6F80J0p3VssskmtsYaa6S7GrYRdOeff37mpd5+++0bjhd3NPNm33zzzfbYY49lda255prFU23BggV20UUXZfuf/vSnZ0L7t7/9rV144YX23Oc+tyORzPfw73//2/7zn//Y/fffn4WhUDFie+bMmca9N2trNO6BBx7IQl3uvvtugwUGS8JeNt10U+M+ytjG+bG+55577JprrsneJDz88MPZOSuttJKtvvrqttlmm7UluntRR7Qn1hLaQUJrERABERABERCBgSBQ220Pq335szZ07z2LpL0z/vR7u++m/9jQGmtlgg2xnXpLEdxYURAS+4zQa2aEeWCUa1W2WT0cI2wEW3/99Us9wpdffrkRw0389iqrrJKV3W677eyvf/2r/e1vf8tCTYr3kBUq/EAcE+ONMC0aHmkEL15zQldWXnnlYpH656uuusr+9a9/1UV6HEDE33XXXfaXv/zF1ltvPaONzdp1++23Z2XpSIRRB+1jIYyH8Bg6AVXWizrK6pbQLqOifSIgAiIgAiIgApOXwAor2fwjv2nTv3KE1R643+yhB2zIBeS0R9yT6QKr14b3fMG119iCFVfOQhIIS0DIhSECmwlBykVYRJwT64iVJpSD8IsqI8yj2TU4F7FIGcRp0RCueKCXW24523zzzeuHn/SkJ9mTn/zkzDNN7PbWW29dP1a2QXgKovzee+/NDnMtwlToVDz66KNZGApx39zvn/70J9t9990zz3mxrv/973+ZJ5v9Sy+9tG255Za22mqrZXyp++qrr7ZbbrklC4WhY8OgzTK744477JxzzsnEOgyf+tSnGmEwePbx8NO54N7nzJlju+22m1FX0XpRR7HO+CyhHSS0FgEREAEREAERGAgCiNzats+wh797UiaoEHiEHTziIQPz77/PFvpiDz1o0/zzdBff0z1LybAvS995u6117h9siQcf6Pg+H1x6Wav5NYiR5voI2ljwaMe+qorx8l555ZVVhzPPLt7dKtt3332bhnbEuYRcEOOcGmEZeIcxQkaKYhMRi9hEiHMfiG3urczwQofI3nbbbTORHeXoDOBNJ1zm97//fSa2Ee/PfOYzo0i2RgRffPHF2TbiGAFM5yVs1VVXNRayp3C9a6+9Nus8EApSNAaeIv4JU9lpp53qoh7vNaEniHhCc4ib5+3BTA9rKVov6ijWGZ81BXuQ0FoEREAEREAERGAgCIQIDKEb62l4K33Q4uOeKeSxtdaxBz2LyL1P2cIeXXV1W/G6q22ds04bl8i+b5On2n1eJ4IekYi3dv78+ZnoRuQhTrFYN4OIsESItrtEWEqzOvH8/ve//82KFMvjMcezTLsJGUHAFg2RS3w44TCIWmK2q+6FmGyMMJeqAZcI/a222iorh1c5hHm2w3/QJtqDERaSiuxs58gPvNPwwhDDRSM2HC8+xvUQ+kXDWx/x6tddd13xcBZf3m0dDZUmO+TRTmBoUwREQAREQAREYDAI1MW1e5MjZhrBhvDFhmoLbdVLL7A1XVyv+O9qT3Kru13o+bevfuErbZ6LbMQn10WQ4tkOkc3+ONaqPjy+CN527bTTTjMG91UZoj8GOBbLIIovuOCCrG14cgnPqDIE+K677mrnnntuFl9NLDfiG49wGJ2LCG9Za621Ynfpeu21186uzUEym6Te6BDeeJ0JF6kyOg2IZGLCEecwT73xIZzZ16w966yzTtYGPPvEbKdx472oo6r97F+8Pdpf/arZ+97X7P4nxzH/JbBTT50cbTn4YPOhwo2L5+30LmlnbRwU/mV35X9Q7bWvNXvJS8qOtr/PY8Ps7W83D2hrfc6f/2z2gQ+YB8q1LtuqBHUccIDZ//1fq5LtH/dXb1n7/FVe20Z6K+7pjDNan+KvF+3HPzb/K966bJRwb4b97nf8FY895n9FzXhey55jnm+ZCIjAwBMoE9mINpal5z1qa595qm3z/rfapt88siuRDairnv9Cu3f1NTMPNoPtEHtFkT2RQC+55JLM015sA6EqhEzQASADCCEjcCszyuBhxhNNGAfhJ4SSEP4RMeScFyKb7fA0s11mdHoi6whCOzWEM0a8eCuL68C8mJs8BmPydiAdnFqsExEe947YTq0XdaT1FbcXb4/2ySebd6fMjjyyeN/tfz77bDPvTY7bXv5ys6c9rfnpX/6y2U9/ykiJ0XLf/Kb5b8jo51ZbHrtlL3hBq1Ktj/srHh8u3FjuBz8w74427m+2Z1D4l90DkwH4Hx475RTzodXm3fqyUq33+ahrO/ro/BnYYYfm5XlWP/95s/32Mx+Z0rxsq6Prrpt/j7/+dd7ZLHlV2KoK47k88cRc/G64oRlCmPbxPG+xRcvTswL+hzo7hz/ue+459px99jHjD95I3GB2rS98wfy9JX99R8vye8HEDz6YJVszQt9HyNt555mPcjF3KZm95jVmxx2Xn8MI97e8xeyNbxytI7Y8xZNMBERgsAkgmMJ7jMczvNnTrrnSVvzZSbb0H86wafOT/6dd3O7tG2xq1z3zOTY84kkterDHUzV5rhGx7VqEWJSVJyyDkBEY4CWPGHBCIYiNxgip4BhZQPBub7TRRg0DHgnB+J07LRDYCO1Zs2ZlZYlpJkYaIYul3m083s0MYRxtTwU650QMeas6KJt686knzfcdx1oJ9hD9WRz/SApB6sZ6UUdeU/nPsUKbf1g+CjT7R8d0nHiERmJjyk+fAnsRP1/60vhvlNc0rYR2We0eT2UI1VbJ1hGD/jCbvxbpidAua8see5i97nVlR/q/r5/8P/tZ86HK1fcwEveVibiKxP/ZyS99ae79rq6p90fw+vK72sxe+crcm4xgfvWrm5U081HnY8QtpX/1q1xct3g9WK8YQfyjH5n/RTcf+VLfXblB+5v9s8EzTYdjxPPRUA/tolNCJ2jHHccefsMbzH7yk9zbPfaIPomACCwGBOoebdctw3N+b0uedKwNX+L/r3tojy29jF344leb/5fNLK7JGoHPEvsowHY7hqhl6YUxWBAjzjkNqSAcgxjqmTNnZhlFOr0WdRE2QiaRdXHcjBgeapbILlIVo01xOhN0iDDCW6JzxOcVV1yRVSbEGaQYn7OdyQ/OSSf+CeFOEY7RDiw859mHih9MpFMU2r2oo+Jy9d250OYL/+IXzY46yvzbrx/MNp7zHDMESZlHjyk7fYRqgzFy1Ed6+jdvdsghRMyPLfKZz5h95Stmz3++2THHjD1W9umII3Kx+7znmR1//GgJ/lE3GcGbhTrQefBXH5WG96uZEH7nO834p92uITY+9KHcu+avaRq8eO3UE3kg6eQUv4/i+YzahXM/7aMfLa990PnTG0/DYXzwR2bxPPgryLqAi3LFMpxQ6B3nlTT5yQCQwmu0rHS8zuLYjTc2VuB/MOt21lntd6z4fWNpZr/4hdn++4+WgA0eY0auf/jD+f4IGcFzzLEwBO+hh/oIfz+HDhm/L+0I7Ti/as3vLiKbvz177WXuUhld6BiUTMYwpqrDDpPQHgNEH0Rg8SCAOKrdfZcN/fwkGz7pOBua638zO7CF7sCau832WSrAJ15+SeWZF+//CpvnaQSnJ8IaARpLiO0Q3Kf4G1C2U8ODzNIL+xXOjwojRCQMgftT3pK74dlOj7GPzCIsZUZYBfeRWmQzSfexjTe9WLZYJj7znUWbYl+s8aS3a7SlrD1478OD36ouPPssRRtvHQcQptnEhuv/yPzVgD8hubAg/yIpZnjt8Mc/5vuInSzGq/I6F68fgsQfvswcpndR+AbM/vAHM0IOEMfpa2PCHPjnjceWON5WXnPEONfhn21qhHQcdFC6p3x79uzy/ez1ZOo+HLf6OIMAkoEA1QX9CAxf8Qozj5fKRAuv3Qspdpqez8Ef/tDszDPzsIVi4TlzzN797jycwV/9LBIj3KHoLYwLDzr/T30q7iRf83zzx4nvoMyDzR8m3vK8+MW5t3Ts2aOfGLTi+T8zixHOjAbnueANBcK8rOMaNVB/mdEBi9+zOI6nmnjk8Rp/nLnfon3ve3koEx1HOuCpFUOpCCNBaPfL+P1FNHdqOALo7Pbon1ynl1d5ERCB3hJArNlVrk1OPMaGTvuFDc1zrdGBzVvpCXbrzs+1/3koyApXXWabH3t05dk3bPdMu+2pW9t010UIa+J/CT+Ihc8sHAuvdrse7cqL6sBiSWA4G6iFQCQGk3hOPNFheNbwdLMwMAzPaZkA4R+vT91ZN4QG3q+PfczMp/a0V70q9zyHZ5tE6Z570ZMomuFJI76yyiiDaOE1A6+JywyvM/9Qi/aJTzBNktmxxxaP5J/f9Kby/ePZ+53vmL3nPQT7mL33vWbEmhZ6tmOqRdx897s5nzjgCd6z2FJiV/mDUjS823R+OvWgFuvp5POb39y69CDyL7srngd68t//frkHmO+L76XVc0MKouLzePjhZizMxHXppeWDFBG9jAlAPPto7QYre558IoCWYSENFSU7eA6LQpuBlB/5iPkQbvOh7KMhJfweveMdecc5HQ9Q1q7kEhO6Say2hPaEfgW6uAh0S6DmmS5qf/ydDZ34Axu68G8dV/fghpvYbbs+327fdntb4H/Dl/33VbbZCd+1oYqaHlhldbtsrxdl3mmEdIjrGGzJmn0htMOjjWczxPbZ/recSVJmzZpVz6rBxCnEUBNuwSQx7RqTwxAy0SqPNhPAMMMjYSNct2jMGkl2EgZGFrOPEL6RxmgXzy1+xmvOzJAxZTrH4RAZX9gmpzUDDZm8htCOfdA2idFxIo1g0buc1kPGEXJwn+oJI4j5JkSGrC0Y1/rZz36WbZMHfEN0bBP7gzt/8djDfscRB2Iv6mhyyezQsP3mN3kZPFipyGYvr2YZSMjrcry+iOJ2snjgxcVjhwDnFTICgvATYkXDENeIaGI6mwltjmO45hmgVma77GL2whc2HmFA4Y035kK/8ajZ295WtrezfQzQYtAVWUMYcIbnv/AwlVbIP38GcoW3nNfkL3pRzo03AHRsikYsNlb0auZ7+/PTU/20tEHkT+gFb2RS4zvg2eUNSlkKJIQmxzmP7zk1vvvobPIHlHAnjNAmzuP5JSSF75vj/D4UjQ4tQpu3NL0IvSjW3+5n3mIRBsJzODIAJjt1ySXzGvg9TAcrtlvvRJRr5/mdiHbpmiIgAk0JZN7re+62mg9uHDrpWJvWcXjIDLt3+2fbrbvvbQ+sMzMTZQi1Je+Ya1t850s2fcH80usvdIF48UtfZ7Wllq57shHUIbKJ843totAOkU3FMRU4grxopJOLlHLFY/38HPHNtL9bQ8zP9reNxIiTlYQBhSGySRNI/mtixAkvwWLwY3pdeJEJBeFLjmzEPt8R9dBG4suZwTLylXNuOhgTQc73wX1FrHZaf3E77r/XdRSvU/w8nKXCYm+zKTcJ78ALN9KLKFZS+RlBiEcJoV30KhFigWgnvIQBUWV5FBE+hJdgZcIzPzKxP/lHjicakYUwaRU3Gq0ls0La+0JEI+IQ7CFooiz8MTomGCIPXgg2fxD7ZgxE6zb7Rd8aN1LxePnztiWNM07byVsJssVUGc9u0RDGIbQRp+9/f16CjixCm9Cpfg0oRRiThaNT4w0V/wQQzWnn7cAD8zdOZZ2NTq/Rqjx/hOMfUXQkCc8hROqDH8zPpoMfIThV9fGWYdasxqOEwTFQmEwlMhEQgUlPIA0PMQ8PmdZheMj8lVexO3fdw+bOep49tuxymWhb6H9bqJcZIrc4+vPWbFbIq3ffx+5fd70sLhshjVAOYV0U2RxH7LGkIhvIIfw4J2wVf6NJxo8yI680XmIGBSJQywzvejfGgEQsbVM39cEFDzNG3dwzghouYZFtJBW3cSzWeK1Z+I4oz31SPpgiwMOKgp1y7Qht6o7vpNiWXtQR7StbE2RE18syzzZZCsqMf7jj/acb4rwYeI9QRHwQrkJ2AHINF42MEAy4ow7iLasMDyPlikasuMMtPUZZhHy3RmYEBC/B/N47a9sQDiMPaHaO/6JmuYZHRuKOqQfRwX2ERWwxwgIvaL+M8J52bBD5n3BCb0Nw4s1EO7x6UYbxCrxNQSQzWDU86J3Uze/c179u9rKXjT2LNy28XSlaDMwlVIgBv6nxdgiB3qnxT6hMIKeTORCKw5gRfgeSP+DZpfgdZvF0VKX1UIjfMwntTr8ZlReBRUogCw85+7c29COPvx5HeMhDG21qt7tIvnO7HczdVpnArrm2yYQ7d+Jie7PvfNmWue2Wyvu6e72N7Prn7FkXz6nQTkV2WdhIiEIqx5uN+AvBGBcMQYnHFnGeGoMTEdp4g5n+PAwPb7cCO+qKMI9eCe2ol3V0RtJ9MIgZF9PJatIy6TYMI2d2uj9mvOT7KM78SFo/Oil41fmu0+8hrQO2sMSKqQB7UUd6reL2cDZojwFgZArgHywxuXiBemUx+UZZnYSMILQJDykT2hE20io1GV7zZoZHq5+GR64Tkc2XfeONZqSFwxAK1EFMbJkRQ4998pO5hx8POr+kiDveBvTLCIdoxwaNP/dU9jy2c6+9KoPALXppiYfGyMhTGPVtn/50/sYjL5E/L57vNDPeDL3+9XFkdM1bJMZH0FF761tH98dWVV50nsWqGHEGJXPd4hso0oGOx3jGGPxbZnQkMAZO49FgHAQd2zSE7GtfM0P4N8vrXWxrXqt+ioAITDCBTAR3Gx6y4842NwkPQcRSb4guhBeidv0Tv2srXXlZ5R3P91CRf77yTTbNxRznIG7Dm40wjQVBGUI7PNlFcRe5octEI2IvYqGJK6a+KkM8ElO9mef/X68H/7OIGceqUulVtaO4/2J/u06oCAI17RQUy93oOic6FRFXHWWYeIb83Bj3R/7uMoNXTPkOg9RbTnn2EZtOJ4I6q2aZpAzG90iHJ7Ve1JHWV9wezrJ+EMZAaMjnPpcveK95DU6sMVk5Cj2vYiWVn/FAkXUES723+Z68ftLr8dobQZ6GKfjghywDBGWbxXBzHE88AyyLRow2cBEpZXb44WV7831VmT+KZ5DDkdc5rWa+Q4iTjxrDu8YrnAgdQUQ0Eyrh3WNQKOKajsOyy+Z1TQahPWj8c3KjP3mVd0u1l2O0YGELkRgdycKh0o/Ea/Ms4k1HSDMTZJnxhqdoDE4ktKjMaEdZp8j/SGfGsXiGys4v7iN0Y86c4t588C4dcX5vytIZIYI7MX7H+d1px0gzSggVb7kYABpGrD0dhmZvX8rYxPlai4AILHICmcAeyR7Ss/AQBkyiOdxCXCOEWdY685f2xD/734omdtVLXmuPPWFVw8/MOUWRHR5b9iPCo+6iyOYSkSO76DnlGKnpCI9A8FFXM6NuBC3CFnFcJUab1RHHEP/URZhE0SscZdpdwyJizPFUz5w5s+FUGFw9kn2LPNzFPNfcD95uhDQ8dve/62Wee2LAI+SlLOyGyWvgTB3EeTMAk+8mNdoSXnEEf/F4L+pIr1fcHs5iipn57hvfyGOMEdx4TFmYqIV4U7xhTOXcpOc1pmI8tgAmJRdiAhEZ8ZZpQX/QMq/ut75ldtJJYzMxkK2EvMKEjET4SXpuus1AyLLBkHjLyZxSNQ11s9zCe++dTwSTXqfZNjnBmxmCghAdLDyZkcGFHM10OJoZccOkh6MOsqmMJ1SgWf1lx0LMlx1L9w0a/7TtbJPFhWe0LPa6WDY+M3agk+wvDCrmdyK+Z55NOnO81SDLSZrDOq7B7xEDKAkPqejtZ0URrHSI6Rzz1mNQDH7N/qbwpgfjjyYDblkTohVCGz4M0kaENxPs7T7H+dX0UwREoE8E6uEhZA+5yHVHh9YqPCQV2Ig2lpUv+put/ZPjml7ptqc/y+Zut6NNGxHqacgIojK82eHJDqHN9cqEdkwTTkx2aoQ4MC065xDbXHZuWh4ByKBCxPl5PqYIMUpbxmMxBXqVx7eTOhGr17qDlkGKl7pmRETHzJF4sLn/yJSCqGVWyqLBknoImWE6drKP4B2P+8NDTYaWEPSI9bIOAgwR4ExDj3AnZ3n6poD47nPPPTdrK20petZpVy/qKN5f+nk4+8A/O1LTsZAOjwGK/EM7/XTzwJc8TR8Dkpgqucyrhncr/YeJcBwJus8EzLHH5nHM6ZVjm0GOCG3CRFJBHGEjEzUI8tvfHhsXHe0trj/wgdwOzDkAABmOSURBVFwAlGWRSMv6w1A38h7j0QwvPJ7AEGD1QoUNT++TiWy8jWRvgUu/p5Pu1ENZaHJXH/vJv6xhzHzVSbw7A3xHeutl1WUdVQa2xmBe3mLwfDOBE4awJ182nUgy/pSFfpB2j/zbvBVKn5+8htGfDIbk+XjWs0b3dbs1d25j2sCR0ePGGAFSHaZWFf6RliluI7R5I1MMUyHmnHCkeFvj/2yy3w+fRjh7c0TqTIzBrLwN2nXX/HPVz4l8jqvapP0iMEUIZF7menjIMZ49ZORNW5v3v3DYs4e0CA9BQMUSAjuL573hWlv3G1+woREBXXbJR1dZza5xbzaG4KIeRGAqsNkuimzKVQll4oGxdKpw4pVJvQcP0uu1G77xlKc8JUsTSBgJE8/gse3UEL/hXV6nB6G0DEgk5d6f3ZGK2D7H3zQittkfmUNoI9ye7c7SqnslxSDeZmZ+xONMeAfhNuHljvt8skc7PC0mkoudyZq0fghzQlGoh2njV3ZNBfMI4+H7e5b/jywOpoxqelFH1FVc50I73cs/fhZG8eNF5Z8aHlQ83Ycfbvb5z6el823K+Q3VjRhKgvkBgyebwYJVxoQovLon7zYDnrz3lqUWYwYk6il7RV1VVy/3tzsbJGw8pitL8dfu9ZmgJyYl4Q8AYQt4LZsZYorXTISoINQZfDZnTrMzuj8WMbLd19R5Df3k33lrOjuDmOJ4WxLfK52j4j35H+psbALiG9GYpvTDW4t3mliyqkHK0So6wVhkPck/jf4kzyjhYWXGNcvyghMSxYyqPKvRCfRXc5nxvNKZxhgIy+9/k39kecGSn9QHn/TNDn8H4joh7OPvB2+NCL3hLRkefDpGMCxOZFW8FG2UiYAILFICo+Eh7ig47dRxZQ+5YzfPfb3L7qPZQyrCQ1JxjcBmYd9aP/h60+vWhqbZVQe+zRZ4fDZiHOFc5s0uE9pVMBF2iE08s0xfjiEc/+KOSsIbCP/AS92u0aZn+P/83/pbfsQ2ubDLvLLN6rvhhhuysBHCPNaqGgvWrIKSY2RG2c0HoZMjG08yGT0iqwdtxptP6r6y8Jmojs4K4hevNiIZ0Z5mGEG8I4DpbLSyLXycDuUJHyHUhHzZYXwPTCffakBmL+qIa6brRqGdHsV7TRo0/pEisKumMi9OWJPW0c42MdiEmeDF5h8pIps8vrxWL8vCUawT726ZWCBLAqEWhdc39dOZ3nmizV8jZbNzMhCOmPKyQWsIDgbIISgYEEHGBybFIfyg6A3s5f0QdtOODTL/uD+8qzHoNPY1W/M7UWWIV1L58VzzDDLREoKwzPBkI8oPPtj8/dboGyO8xmTqQUymb4uKdRBeESkhEZ9lRsgRS5kh6Mt+d6IsOeIJIcPwYhOjffTRox1gBlueeGJ+vJOfiGl+/zg/JsyZMycPA4l6ikKbAdOE4MCEuGz+TtAJwTHQzNp9jpvVoWMiIAJtEeg6PGTjzez25+5VmT0EEVfmvQ6Bna6Hllm2aZv/t+f+du/6G1vN/w5SL+K8HW82ZVnKDFGLkRs6yhDWwEBEvKkIS66DsY974XNk56D9RUO0E1bBBDFME85gvmKKuuI58RnBGVOTM+iwl4bXeBcP66MDQfgHMeB4r9kf99jqepTb1OdwQVAjsqmHfQj1Ku9zVZ2EkLBQB+ErdJDI4hLhKFXnpft7UUdaH9vDWWw23udmr515NYvQ7pdniKwivC4mThuh3WnYCL3Dsl4a8Zu8Nia+s8o66FlWVdHVfiYDwogzRTzzWihCSvIjeVYFREmIcNaIHzynMdg0yvZyTTgCQq5KJMa1Bpl/3AOe1DZ6zVE8W1dls6BDFF7WmBBqzInJBwQjedEZKEuHhYGQP/+52cc/ntdBxpBmxndEeBcDa3kDVGZ4xovp+KJcxT+LONy39cgI8KaDNItCG+8+nRdCbXg1y3OJI6CZ0ZGAkUwERKBvBOrhIT/9kQ39+NhFGh4SHuhUYCPUWBbM3tuWuHTkf2zh7h9cb0O74fkvzLJiIIgRvFEXAi2WYshIM5HNJSKFHrM/hsWkKwhdvK5hCODIBBL7ihkxYj8xyrf420QEaFpHHC9b870Q+4xHnfas3SfHHF7rZp7rsrYV98Gee2Pp1gg/Kcv40km9vagjrjecedIQSpEyLo6k6xCDnoqmL0a2EcQwHi284wyEZBCmzzrUljE5SNlgSDoPpDhDuExWozOAx5LX+7waJ6dxOrkPcfK0/8ADR3nwi4rAwBNZlbmiF/dL/CshQ80yOnCdQeZP+0m1l3qo6eyRIYQ3DIROYPDHc0qHMCz5gxm7xrUm5IPBrZGmD7HN4BE8xa06OZGhhNAQwpgOP7yxCYjpVvU0ntXfPSNen5ZCm4E/aYfm0EPzwaNkKuKtAR2MZoYnn7cKMhEQgZ4TqIeHnPB9H9P1y6ZhGmUXZ3KZO3bb025ncpllls1E78IOwkNScR3bIbIRxLX9X2Lzz/+LzZjz+zGXn+dx2VcfdEg2iHpoxJsdIhvvZyxpyAhCPDzUYyorfCCWmPCQNC4ZYRxTfqfFEc8IeYxrIYTxwFbZDoTaNjGuw6DEuDbtxYNOfDYDBJsZ98ygxU69yM3q1LGcwHAWI0lsNK9weSWMhy21X/7SssFP7OMVeL8MTxVCG6+e/6JlGSC8R9rUCOp/3vMYcdC0WMuDDGrjVT1ChwFXi8p4fY43k8k2iIMl8wtx7fGqnnZ4jJO95CV56EjaLoQf992nHmr9UgxyqxLag84/bjLN+EHHApH9ghfkA/KiDCEUCL6yzCR0DBlATKz1eJ9FzqWTeeyxuShGQLcKm6JzTGcAzwnPDZ7rHXfMfyei3YtyTepJxnQ0y2kd7YnOe8lo9CiSDb6eObP+Mdsg7o4ODh2jdliPZ5Dm2CvqkwiIQIFAFh5y1hk2RPaQS9yZ1aE95OEhc93bfNc225dOLoNAbBUeEp5mBHKIa9ZxHnUs9M/zj/i6zTv9VJv+x99Z7aEH7cENN7Wbd93T5k33fNkeWhrnUB9iMzzZIbLjeAjtVmKb46k3uxkawiVYemWI9OJgSTJ1bFv1Pzy5MCJ9q0Wpf5JrL+6bw1lWhH33zcM2iHlE9PHPDRFI3LC/2sgMgVEczNVLOgwOJE41BuAhuFsZHuBWafUIfeD1cTPRfuONeW7jWbMWrdAmVIaQEEQdxi/Du96Vvx7Hc4ch7iJzRb4n/0kcF3nOPb9mXw0hh8ea6xVt0PkX7wcRx3POvTJmoF1joicEJvHC7Yi/Yr2EZCG0GfCKuOZNAm82CAuq8mDQGaWzRXYfMt7wLPAc82aH7Cbx/BSv1evPhIDgkcFjjgCms9qOkVKUNzlVQpvODh2JmMqeOvFiE2LDPdPJI+8/HU3+bpQZjHh+ZSIgAl0TmGzhIVUCOwQx7UX0sl6wx7720KzZ2WA9QjuGfODe9CSBA2IaYY3QRnCyDiEfQpu6WonsriGrgsWSwHAmVEnbRygCnjnEdmr8Q0N08Jq2n8YregQnr8vpVY13yve0jcSek82BpVlKnJiRr+g9S+sq2/Zf4CyXcoQXlJWp2kfsOK/6CZFJM6uQnSKMzA+tZl3sV9x8tAEhhXe1zJMbZarWk5l/2maEG55kBCtildkGaXtqCMmqEIR4fso8EwyyrDK8sgwEZDIaOpgMNESwk1mGOHxCn8guQ3x1YSarbAAlYREI8Xh+iAenDsJbjjlmdGAhz2mvjY7w2WfnE0LR4fJ/QqWWhuREATqXdCr23HN04qU4FuvoXPKmDeP7ecc7cpFNakw8+PxOMyskHRM6F8XONG+LxjMRUXZB/RABEYBAPTzkRP+bctovxh8essvscWUPiZCQdI34jSX1YIcYDoFNWrvYF+U4j7q4rzjOPoQ2Ijs82ght9odwl8jW78N4CeRuSk97kk2eweh8Yj2Z7Q5PKq+kEZ9l3kyu2EmWhnZayIx5LL0yPPWEwyAE8PiVvYonswNxzrz2bvV65fjjc7GFB48FgYXQLZv1stU9IIgQscRmF8N14lw8cq0GO/ZDRMX1Y00njPAKstB0YpOVPxlt8KjyNoBlzhzLJjbi/ojXJrtF0RC95JbnjU86WAMhR0eV36GYGIVMN0cdlaeuQyBi6aBbMs3gaeUYafJIb0lnhgGxGNl2mKiJGHzaQ7YPOrp4d8k6Q3gLceR08NLng9g+4vmpC29vHKOjTNYaBgx7Sqbse+R5xwNNJwMxzEKdhCphdCwoW9WJZEwFzy9COH3Txe8S7aN+fkdiYHMaH0g6Qq7HIOgqQyTT2eYNAb+7dCJIBci58RaLcB0GatNRYT+/nzGqnu+YAaUyERCBcRHoOnvIRk+x231q9Du326Ev4SGIYMRvUQingjiOUyYENkIa43N4vdkOgR3ebPaxRP3jgqiTRMAJDI+hgNeMpZn3d8wJk/wD/4RJBYZ4J0yjzPDEcc9k8Ih8wWXl2IfQwuOeGiL5oIPSPa23CWehI/OiF5UP4owaEDlVXtQog1Acj9CP89tZ0/liYh48vZ3YZOXPZCzMLsj3wPcPP7yldH5SEZ3eK/HPfB8IdM4L44/2gQfmntXYR8cUIc3kT2wztoHc52EIQ7yy/J6RVYTj/gd9jBESwUBYBssilJnUiToQ2ghO2oLXuixTCjH9LHSYaS8hGHQouW/EMc8UAptXp3TmwtKwF95kUb7KSEtYNskOE+wQ/pQaXvfIwsJ+7pcQF2ZfrTLENL+XdCTnzMlzhJNthIHTYQxO5d4Iu2F2TTzlYTyvMQNr7NNaBESgKYHMe33P3VbrJnvIDjt5/PU+9sA6M/PBjf73knpD1CJcYwkxG97qCNeIz6yjTIjeOBcRHQs3lQrsuMk4zrnhxeYYdZCJI9rEca4dS1yXclFH1Km1CHRKwHO0LwqXaKfN6kN5XuGX3SpeN5Z2DJGCeAnjPDx17Z4f58WaNuH5KzMEFtdrNVkJISiEGjAArZ1BaGXXSvchWBAvRfM/OFl4UZX3vVi++Hmy8T/uuNxbisim09Nr4+0Q90znrdiBY5ZIT/DfUQeJ8Kd0QhvqR4guSmPQNCEfxEmXhcnQFjzViPowvOztDtglfIb7xCuNiMYrTaeC57FVKJlPUlD3ZvM7gTe77PedelIPfLRTaxGYwgQyGXCV/3774EYmlxma553wDqyePSQNDxkR2FQTYhXhGsI5FdNl21GOdZm4jjqbNZPQEO4NUc2ywN82srAdx6gnrhXtKF6z2TV0TARaEZg6QrsVCR0XAREQAREQgSlEIAsP+cOZNvSjY2zoIn/71aE9RHiIZw+5c9skPMSFbfjvELEhkotiNkRt6sWOMiF0WUcdqbBmux2jHSyIapYQ2PGZOqL+6AREe1m3e5122qIyU5eAv9eWiYAIiIAIiIAITAUCmQjuNjxkx51trsdfT4bwkGbfWQjlEM18DuHNeWyzjyUtw7ZMBHpFQB7tXpFUPSIgAiIgAiIwSQlkAnsxDA9pB3d2716QdSzpeSHIQ3TH57SMtkVgvAQktMdLTueJgAiIgAiIwCQnsLiHh3SCPwQ358R2KqrT7U7qVVkRaEZAQrsZHR0TAREQAREQgQEjkInIJDxkaO5tHd3BwuEZdm+L8BBEKSEWLBFbXRZ3HfuiTMRfx7nUEwuNlNjt6KtS4QEgIKE9AF+SmigCIiACIiACrQhkAnuKhoe0YqPjIjBRBCS0J4q8risCIiACIiACPSBQDw/x9HxDF5/fcY2TPXtIxzekE0RgEhGQ0J5EX4aaIgIiIAIiIALtEKiHh5xyog2dfJwpPKQdaiojAouegIT2omeuK4qACIiACIjAuAgoPGRc2HSSCEwYAQntCUOvC4uACIiACIhAewQUHtIeJ5USgclGQEJ7sn0jao8IiIAIiIAIOAGFh+gxEIHBJyChPfjfoe5ABERABERgMSLQm/CQ59vtu+xujy27XH0K8qxe5xTp9MpS80U6vuK6LD1f1JOuF6OvQbciAj0hIKHdE4yqRAREQAREQAS6I9B1eMjGm9ntu+9ld267gz3uTVm4cOGYmRARxJG/OoRzUVDPmDHDYl+UidzXrKOOENfcMdsyERCBcgIS2uVctFcEREAEREAE+k6gV+Eht+2+tz24zswx3mvqDkFcJbBTYV0lsOPcqCuEdaz7DkkXEIEBJiChPcBfnpouAiIgAiIwmAQygX3l5Wae+9pO/6UNzXusoxuZv/IqdsduCg/pCJoKi8AEEJDQngDouqQIiIAIiMDUJJCFh5x1hg396JjxTS6j8JCp+eDorgeWgIT2wH51argIiIAIiMAgEFB4yCB8S2qjCPSHgIR2f7iqVhEQAREQgSlOQOEhU/wB0O2LgBOQ0NZjIAIiIAIiIAI9JNCL8JC5s/e2u7bZXtlDevi9qCoRmAgCEtoTQV3XFAEREAERWKwI9CI85J5n7mJzn7uXsocsVk+GbmaqE5DQnupPgO5fBERABERg3AQUHjJudDpRBKYEAQntKfE16yZFQAREQAR6SaAeHuLp+YYuuaDjqh/y7CEKD+kYm04QgYEjIKE9cF+ZGiwCIiACIjARBEbDQ06woZOPt6G5t3XUjIXDM0zhIR0hU2ERGHgCEtoD/xXqBkRABERABPpJoOvwkCesanfsuqfdPmu2PbbMsmNmb6TdMeMiMzDGtOcxS2PVOsrF9OicG/Wk635yUd0iIAKtCUhot2akEiIgAiIgAlOQgMJDpuCXrlsWgR4TkNDuMVBVJwIiIAIiMLgEug4PmeHhITsqe8jgPgFquQj0loCEdm95qjYREAEREIEBJNCT8JDdPDxkF4WHDODXryaLQN8ISGj3Da0qFgEREAERmPQEFiyw2llnmJ3w/fFlD9nkqTZ39700ucyk/6LVQBGYGALDE3NZXVUEREAEREAEJpjAVf+y2iEH2dCN13fUkIVthIcwODGWGLgYAxtn+PmxHesokw5uLA5wpJEMdJSJgAgMDgF5tAfnu1JLRUAEREAEekUAT/beO9vQTf9pu8b5ZA9ReEjbvFRQBETATB5tPQUiIAIiIAJTjkDt+n+3LbIfKgsPQajXahk3vMxV3uvwWKde7KL3ms9RR6Tmo2J5r6fcY6kbXgwJSGgvhl+qbkkEREAERKAFgRVXalqA8JB7yR6y+972wJOePCb3NQI7hHGVwE6FdYjtosCOc0Nch7COddMG6qAIiMBAEJDQHoivSY0UAREQARHoJYHaak+02h772LQzfz2m2gWrrGZ3z97Hs4fsbo8uvYwtcM/1whHvdVFgh3AOIV21jnKsy8R1CO0xDdEHERCBxYKAYrQXi69RNyECIiACItAJgYULF9rjjzxsdsy3bOiv59iCFVe2B5+1i9297Q72mAvrefPmZSL78ccfr4eIhEgO4VwU1qkXO8qEuGaNoKaOVFjLe93Jt6ayIjB4BCS0B+87U4tFQAREQAS6IIBnmgURPX/+/ExUP/bYY/boo49mC9vsx5tNOQyBHOI5BHYqrGNflAmBHeI8xHUI61h3cRs6VQREYAAIKHRkAL4kNVEEREAERKA/BFIBzHYIajzeIYZZI5xDTJetywR21EfL2Y76+nMnqlUERGAyEpDQnozfitokAiIgAiLQNwII3vBUhwAOgY2I5hifowzb7YhrxDb1UT7q5SbYlomACExNAhLaU/N7112LgAiIwJQnEGI4vNV4sTE+E1aChXBGaEc51rEgqmOJ+kJYxzqrSD9EQASmJAEJ7Sn5teumRUAERGBqEwhRjEhGNKfeawR3iO4Q0VGuKLCph2NY1Dm1yeruRUAEUgIS2ikNbYuACIiACEwZAqlI5qb5jJAOkR37Yn+I7jiPNUuUyzb0QwREQAQSAhLaCQxtioAIiIAITA0CIZC52/BIs0Zkh3ebYyGmORbbsY7jrGUiIAIiUEZA6f3KqGifCIiACIjAlCAQopp1LMUbD2HNGot1sZw+i4AIiECRgDzaRSL6LAIiIAIiMGUIpKI5tkN8x+eAUfwc+7UWAREQgSoC8mhXkdF+ERABERABERABERABEeiCQD5UuosKdKoIiIAIiIAIiIAIiIAIiEAjAQntRibaIwIiIAIiIAIiIAIiIAJdE5DQ7hqhKhABERABERABERABERCBRgIS2o1MtEcEREAEREAEREAEREAEuiYgod01QlUgAiIgAiIgAiIgAiIgAo0EJLQbmWiPCIiACIiACIiACIiACHRNQEK7a4SqQAREQAREQAREQAREQAQaCUhoNzLRHhEQAREQAREQAREQARHomoCEdtcIVYEIiIAIiIAIiIAIiIAINBKQ0G5koj0iIAIiIAIiIAIiIAIi0DUBCe2uEaoCERABERABERABERABEWgkIKHdyER7REAEREAEREAEREAERKBrAhLaXSNUBSIgAiIgAiIgAiIgAiLQSEBCu5GJ9oiACIiACIiACIiACIhA1wQktLtGqApEQAREQAREQAREQAREoJGAhHYjE+0RAREQAREQAREQAREQga4JSGh3jVAViIAIiIAIiIAIiIAIiEAjgeG//+2ixr3aIwIiIAIiIAIiIAIiIAIi0BWBoZpbVzXoZBEQAREQAREQAREQAREQgQYCCh1pQKIdIiACIiACIiACIiACItA9AQnt7hmqBhEQAREQAREQAREQARFoICCh3YBEO0RABERABERABERABESgewIS2t0zVA0iIAIiIAIiIAIiIAIi0EBAQrsBiXaIgAiIgAiIgAiIgAiIQPcE/h+Veonb1YAqtgAAAABJRU5ErkJggg==" alt="" width="638" height="81" />

 NSString *bottomStr=[NSString stringWithFormat:@"原价%@",model.standardPrice];
 NSMutableAttributedString *attrString=[[NSMutableAttributedString alloc]initWithString:bottomStr];
 [attrString addAttribute:NSStrikethroughStyleAttributeName value:[NSNumber numberWithInteger:NSUnderlinePatternSolid | NSUnderlineStyleSingle]
 range:NSMakeRange(, bottomStr.length)];
 self.bottomLb.attributedText=attrString; 

39、xxx文件 is missing from working copy 解决方法

解决方案:
1.打开终端
2.cd 到警告所提示的文件夹下
3.执行命令svn rm --force 丢失文件的名称
4.回车

5. find . -type d -name .svn | xargs rm -rf //该命令为直接删除指定文件夹下所有SVN相关
6. sudo find /Users/KingKong/Desktop/Scitel_Project/iOS-BigEvent/ -name ".svn" -exec rm -r {} \;//红色字体为项目路径

40、解决 UITableView 等UI控件下移的问题

.//下方显示不全
_tableView.contentInset=UIEdgeInsetsMake(, , -, );   

、//其他UI控件下移复位处理
self.navigationController.navigationBar.translucent = NO;  

self.edgesForExtendedLayout = UIRectEdgeNone; 

self.automaticallyAdjustsScrollViewInsets = YES;

self.extendedLayoutIncludesOpaqueBars = YES;

41、UITableView 复用时实现修改FooterView背景色方法

- (void)tableView:(UITableView *)tableView willDisplayFooterView:(UIView *)view forSection:(NSInteger)section {
    view.tintColor = HGTableViewBackColor;
} 

42、修改UIProgressView 高度的方法

CGAffineTransform transform = CGAffineTransformMakeScale(1.0f, 5.0f);
self.progressView.transform = transform;

需要导入CoreGraphics.framework包

43、根据index(下标)获取TableViewCell

 NSIndexPath *indexPath =  [NSIndexPath indexPathForItem:i inSection:];
 UITableViewCell *cell =  [self.tableView cellForRowAtIndexPath:indexPath]; 

44、iOS 中 _OBJC_CLASS_$_xxxx 问题解决方案

错误代码：

Undefined symbols for architecture x86_64:

"_OBJC_CLASS_$_QQApiInterface", referenced from:

objc-class-ref in AppDelegate.o

"_OBJC_CLASS_$_ShareSDK", referenced from:

objc-class-ref in AppDelegate.o

objc-class-ref in RecipeDetailViewController.o

objc-class-ref in showViewController.o

objc-class-ref in video_show.o

"_OBJC_CLASS_$_TencentOAuth", referenced from:

objc-class-ref in AppDelegate.o

"_OBJC_CLASS_$_WXApi", referenced from:

objc-class-ref in AppDelegate.o

"_OBJC_CLASS_$_WeiboApi", referenced from:

objc-class-ref in AppDelegate.o

"_OBJC_CLASS_$_YXApi", referenced from:

objc-class-ref in AppDelegate.o

ld: symbol(s) not found for architecture x86_64

clang: error: linker command failed with exit code 1 (use -v to see invocation)

原因：

Xcode升级到6.1.1或以上版本后 默认让所有App都通过64位编译器编译。原来在Xcode6.1.1以下版本的时候默认的

Architectures只有（arm7,armv7s），到6.1.1或以上版本默认就带上arm64的参数了。

方法：

1.把1.选中Targets—>Build Settings—>Combined--->Architectures。

把build active architectures only 改为 NO。

2. 把最下面的Valid Architectures中的arm64参数删掉就可以了

或者：

双击Architectures，选择other，删除$(ARCH_STANDARD)，然后增加armv7和armv7s（写上：$(ARCHS_STANDARD_32_BIT)）。

3.clean 再build。

设置好后效果图：

45、Xcode更新到7.3后会出现NSObject+MJProperty.h报Cannot create __weak reference in file using manual reference counting错误

解决的办法：

在Build Settings---->Aplle LLVM7.1 - Language - Objectibe-C

---->Weak Reference In Manual Retain Release 设置为YES

46、清理Xcode中多余的开发证书方法

即此处显示的证书

进入此目录 ~/Library/MobileDevice/Provisioning Profiles 删除对应的证书即可。

47、解决no index path for table cell being reused 问题

问题原因是：我用nib自定义了一个cell。作为我的tableHeaderView.当然在我执行下面的这段代码的时候，tableHeaderView

的显示没有任何问题。

headCell = [[NSBundle mainBundle] loadNibNamed:@"RRTableHeadBtnCell" owner:self options:nil][];
self.tableView.tableHeaderView = headCell;
 

但是：当我有数据需要更新cell的时候，当我要执行下面的代码的时候，标题的error就出现了。而且我的tableFootView 也同时消失了。

 [self.tableview reloadSections:[NSIndexSet  indexSetWithIndex:] withRowAnimation:UITableViewRowAnimationFade];  

问题是由于将cell作为section headerView 导致的题目所述错误。

解决方案其实很简单：

 self.tableView.tableHeaderView = headCell.contentView;

48、Xcode 打开项目一直显示Indexing... 解决办法

Xcode用得久了，代码中类和方法等字体颜色不提示，文件失去关联，command+左键出现symbol not found。

defaults write com.apple.dt.Xcode IDEIndexDisable 1   这可以解决Xcode一直处于indexing状态；

* 需要时候，把1改为0就可以了：  defaults write com.apple.dt.Xcode IDEIndexDisable 0    这样你的Xcode就

可以正常代码提示了   当然，这还有可能是因为工程索引文件被破坏导致，可通过以下方法解决：

1)、Xcode -> Organizer -> Projects ->把所有工程中的Derived Data 删除Delete掉。

2)、进入~/Library/Developer/Xcode/DerivedData 这个文件夹，把里面相关工程的文件夹删掉。

49、iOS修改UIStatusBar 文字颜色方法

1)、在plist里增加一行 UIStatusBarStyle(或者是“Status bar style”也可以)，这里可以设置两个值，

UIStatusBarStyleDefault (默认黑色)和 UIStatusBarStyleLightContent (白色)，同时必须在plist中添加

View controller-based status bar appearance 设置NO; 此方法只对iOS7以后的操作有效。

50、 真机调试弹出 "Mac OS X"想要进行更改。键入管理员的名称和密码以允许执行此操作("Mac OS X"想使用系统钥匙串)

解决方法：

打开钥匙串访问选择系统下对应的证书点开双击，将访问控制项改变到允许所有应用程序访问此项目，输入一次密码即可，

以后就不会弹出了！

51、Xcode8代码出现输出ubsystem: com.apple.UIKit, category: HIDEventFiltered, enable_level: 0 ...

解决办法：【Product】-【Scheme】-【Edit Scheme】-【Run】-【Argument】-【Environment Variable】

添加keyValue【OS_ACTIVITY_MODE   disable】可以停止输出打印此日志

aaarticlea/png;base64,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" alt="" width="697" height="251" />

52、实现在一个viewcontroller上加载另一个viewcontroller方法

[self addChildViewController:otherVC];
[self.view addSubview:otherVC.view];

53、解决Xcode8 打开Xib文件后Xcode7 无法打开并编译的问题

修改如上图两个地方即可。

54、打包Framework中如果存在Category 造成在引用时崩溃的解决方法

在引用时需要在工程中的 Build Settings ----> other linker flags中添加 -ObjC 即可。

>>>>>>>>>>第一部分<<<<<<<<<<<<