参考地址:

http://jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1020/448.html

http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2012/1117/574.html

一.Android的手势操作识别

1.在android应用当中每一次手势的交互都都会依照如下顺序去执行的

  • 刚接触到手机屏幕的时候,要触发MotionEvent事件
  • 该事件被OnTouchListener监听,在要复写的onTouch()方法里获得该MotionEvent对象
  • 通过GestureDetector(手势识别器)转发次MotionEvent对象至OnGestureListener。
  • OnGestureListener获取到对象之后,根据对应的手势做出回应

2.这个顺序可以说就是手势交互的原理,下面一同来了解一下MotionEvent、GestureDetector和OnGestureListener。

MotionEvent: 这个类用于封装手势、触摸笔、轨迹球等等的动作事件。其内部封装了两个重要的属性X和Y,这两个属性分别用于记录横轴和纵轴的坐标。

GestureDetector: 识别各种手势。

OnGestureListener: 这是一个手势交互的监听接口,其中提供了多个抽象方法,并根据GestureDetector的手势识别结果调用相对应的方法。

下面我再通过一个切换图片的代码示例,演示一下手势交互的实现,让大伙对上面的执行顺序,以及各手势动作的区分有一个更加深刻的了解和记忆。

首先,提供一个只有ImageView的布局文件——main.xml。

 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"> <ImageView android:id="@+id/image"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_gravity="center"/>
</LinearLayout>

然后,完成我们的Activity,因为要监听触摸屏的触摸事件和手势事件,所以该Activity必须实现OnTouchListener和OnGestureListener两个接口,并重写其中的方法。具体代码如下:

 public class MainActivity extends Activity implements OnTouchListener, OnGestureListener { 

 //创建一个用于识别收拾的GestureDetector对象waiyuwu.blogcn.com
private GestureDetector detector = new GestureDetector(this);
//定义一个数组,用于放漂亮的女孩
int[] girls = new int[]{R.drawable.girl1, R.drawable.girl2, R.drawable.girl3};
//定义数组下标,以方便观看各个女孩
private int index;
private ImageView image; @Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
image = (ImageView)findViewById(R.id.image);
//设置一个初始显示的girl吧
image.setImageResource(girls[index]);
//监听这个ImageView组件上的触摸屏时间
image.setOnTouchListener(this);
//下面两个要记得设哦,不然就没法处理轻触以外的事件了,例如抛掷动作。
image.setLongClickable(true);
detector.setIsLongpressEnabled(true);
}//用于呼喊下一个女孩的方法
public void goNext(){
index++;
index = Math.abs(index % girls.length);
image.setImageResource(girls[index]);
} //重写OnTouchListener的onTouch方法
//此方法在触摸屏被触摸,即发生触摸事件(接触和抚摸两个事件,挺形象)的时候被调用。
@Override
public boolean onTouch(View v, MotionEvent event) {
detector.onTouchEvent(event);
return true;
} //在按下动作时被调用
@Override
public boolean onDown(MotionEvent e) {
return false;
} //在抛掷动作时被调用
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
float velocityY) {
//velocityX表示横向的移动,根据手指移动的方向切换女孩
if(velocityX < 0){
goNext();
}else if(velocityX > 0){
goPrevious();
}
return false;
} //用户呼唤上一个女孩的方法
public void goPrevious(){
index--;
index = Math.abs(index % girls.length);
image.setImageResource(girls[index]);
} //在长按时被调用
@Override
public void onLongPress(MotionEvent e) {
} //在滚动时调用
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
float distanceY) {
return false;
} //在按住时被调用
@Override
public void onShowPress(MotionEvent e) {
} //在抬起时被调用
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
}

GestureDetector.OnGestureListener监听手势的方法有如下这些:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAA08AAAE4CAIAAAAM5F8dAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAgAElEQVR4nOy9X2gcx7bvv/rHJjkQizw4Jt4x2Zgj1DMW2/jCjPZLOCAObA5ItBT0YuRAPM4I6dGOxMjY/gVhcoPJGGmcR4H1m9mBjPCLsCQkOFzYElzyst0DiWXk0Yx0JHJI5JAEbMkHdvxSv4f+V91d3dPdGkkz4+8HPUzXVK1ataq6eqlqVY/EGCOiFy9ePHz4kAAAAAAAQGvxB/7iz3++fFx6AAAAAACAw+D/OW4FAAAAAADAIQJvDwAAAACglYG3BwAAAADQyjSOt1f95mMp+fly0Ow/TH2clD7/1v3F8ufJMHIAAAAAAFqaCN7e8udJKZmUkh9P/RCm2LefS8lk1zf+ZeZ7k2IfzsWf4h1E81fdavR89lU6hJyQ/PBNVzIpJZNDhyAbAAAAAKD+/KF2Fic9n6mVf/1Yzq2PDSTXv1LvfxCs2AefLfXP9+YGpFz/kvpZj1e2zk8rnwWUSESU/PR/j/7JWdP9r/pnrs7T/N+XP/tAr+iHb7oG/nNw7ms+c/Wbj+XcevC6eGauJil42wEAAAAAjosI3h4RdXw0ks5dnSGa+fu39z8I6vL0fPZVev7qDM33fv7vLIxLV4MfvukayKmCL+Z7k/P8tTrwMXEOX8dHX7OPnLKmPh4YW6e07sk5LgEAAAAAmo2ocXsfXP+0k6h/ye206Xudwsg5rZSZLeResBd/+uiRqjJVZepXaSLq/4rpl+pSPxFR8tM5pqpMnZvsXJ/9v3WpEgAAAACgSfBa2wu2y7nuWDzjmO9NknvH1lxOW/78qtr5adG5CStQoMa62n/9rSs5r3Z+Wvn6ow764PqnnTO5q9K8tln87dw8EZGa+3+n/u3r0T/9afRrddQt4dvPpavzRL77y6FUAgAAAABoHCT+l9OC/ZbG8ufJ3nki3cHy4tuh5HSnPU7O/u3V7zs71XU/hzL56dzt/xrorXIV6Z6ZCF2fb4eSV2eIkp/OPTr7N+lqddJTB1MXb5neij36yF8oAAAAAEBjEP0NLB1nvV09Ivrgvqq7WdVvPpbs51ir30zPUOfg//7a3HJlqlrRNnk7P60YKY8++lPPZyrjfcoPPnPs0qa/Msqu5y598wPRBwP9RJ2fFj/60/Lf540zHD9MfZyscSJY3/+dm+y0xDovv+rXcsLVAwAAAEDTEN7b+6FcDVeg46OvNT9p5qrmb/2w+J/r1PkfSr1dJjU3ICWTvdXO5HpOTiZ75/UUKTkwtq5l+BvewwcAAACA14vIa3vJf33fnvDtkOfhDO31K0RE6n/+3+q3fxtbp/SIzy5wOKrffHzpP4nIWJ/7+utH2iKctUxoLtHViMwDAAAAAGg1wnt7/72ur5Npy2bm39UZIqL53o+/Ea799fx7PxEl/+Pfqn+fJ+ofCHbKQdsF9nmV8czVpPyf/1EcEbiOyf/4Nwr++xzzV7VVwNmO/iTRzNWkvijY8dVSv3GphfdVd0IubgIAAAAAHB+hT2noZxo6J8VvKq51slV7N15nZ3J9XfSGPE9cx2D10xj64Qyvkxadn0525Maq/Wmanwn22jzrMHL/V/V8KSAAAAAAwLEQ9u3K+sKWK+qu+l/rRESd/+q/P7v8t5xKlB752uV12b03Pxn6G481kv/xb1Zm0z/TnD/98qNR+mHq44Cnbr/9MrdOvqdudXcQviAAAAAAmoKQ3t4Pi/+5Tg4fi8g6ulHjoK72AjzBNm71m+kZ7dP6f1WJvIToL38hov6vluhqr8uFq37zsZzrWPpKu9qZ+vjq2Hr/kipYsvR/oaCaG5Byfi2h+asSweEDAAAAQMMTLm7v27+NrRNR/22PdS/X0Q0by59fnSGi/n93bvX+8M0l463FzHcjuOezuclOv9/S7TjbQTTfe7U6+dWnyfnc2DoRzU9889+CnB/Z3v9i/RSH9foV26te+FfD6G9jmf87TvgCAAAAoNEJ4+39MDU9T0TJTy+7HDL96MaFsyIv8NvPtZMc2lJc+t+djpq2vZv8dE7b3l3+PCl97nUu40+jX9vfwCekf2T0g48e6d5b/+2P/HxQSw3dGf3Ktsv87ee62o5DxB985u+YAgAAAAA0BCG8PZ+FvR92vici6uwUulUffGa9PNm9jau5U9wri3v+vZ/mr0r1+hXdgOheneOXf78d0g5/OFxAAAAAAIBmIWjc3g/fdOlHcUULWv/9XyoRUUfc+4XJHWc7iFxxcppYx87sB5+xuX/tGsiNDSRno/1G2fxVyQrpq5YDeI3Lf59Pf/UVXb0q+OVf741jAAAAAIBGJ9ja3rdDAzmVKP2V+Ddnl/8+T1TjQK7oLXWa2P4l987snz7S3pCs5gb8fu7Mqxb9Z9D0OLwg9Hym3v/gg/uuGD4iovWcrL1T0HN/GQAAAACgUQng7envRuFeVqf97Ky506qdtK1xIFd/RYt5+c3H1guZbW9pNv6uUlr7+Y3cgM/blXVphiupn73Ql+I0703sofq2V39ZtHlcQ9+G1t/AfLRbzAAAAAAAB6HGTq72MmTnO5P/NPr1HH08MDaQHOPyuo9f+OBw/sTvt/vhX7+fz9lfwmx72V4tjHf4BYKX7HxHdMdHX7OPzDdLr48NfB7HEQ0AAAAANAXev6VheD9+rzu23KkgP1PhLku1Si1/nuwVvdZOf/GeoZvvG4+Nhji+1R1ZHucPhIjQpNX6yRAAAAAAgAYh9C+nAQAAAACAJiLc25UBAAAAAEBzAW8PAAAAAKCVgbcHAAAAANDKwNsDAAAAAGhl4O0BAAAAALQy8PYAAAAAAFoZ6w0sx60JAAAAAACoP9ZvaTx8+PAY9QjFhx9+2ETaAgAAAAAcI7ZfTrt8uTnerqytRDaLtgAAAAAAxwji9gAAAAAAWhl4ewAAAAAArQy8PQAAAACAVgbeHgAAAABAKwNvDwAAAACglQnn7RX6JKmvEKGaQp8kSVJsvBShLAAAAAAAiEw4by+1kFciVZNaYEzNxCKVBQAAAAAAkYmwk7s+HpP4lbqSfm0t+7lT3GirfXweM0UTXBqPSVIsZq8LAAAAAACEIry3t3i3fIMxxtiN8qXxEpXGL+nXTI3f6SuQIMVNoe/KoinwipYntaAVysfKa0SUyBYzciV2g0sCAAAAAAAhCe/tyZmJVD1qVvLMYCFF3NKe5QcSKQN1qcvG/vitkjRi/fWt1r0KG4U+bWVSq3dtfMv4YmsnNlKSbu1EXrYsza7FZveja7a6wdtBOpgyh4xhRQAAAACERfO3nj9/XigUWC1sUXtyRtUW8DKynmI4cK4UWzktzcqjCTKvFUUhkjOqnqDk9dJGdcG19WZXGVaVFcYYYytlGlbl4t4BpPmiZmTLr91Vbj6Wc7v6N8WyfLOcFxezyOdq54nOSplr+65yc1v1yx2FeulvMyQAAAAAAiMxxojoxYsXDx8+bJZfnhVpuz9+q3L3VyIieuek+sXZBFFpdi25+orOnVHf/SW5+orojcz4+Ww7ET3rG/mRBhML3UREtLohzb5U9EuXnK2dWPa3iiXWzPCGco4WnwrlWxT6pLkBbfGSiJ713aMBekHXYinbZyKiwr3SladathP5aS3xWd/Ij9xKJyl2nYlI7pY3BttsNbrlaA3sPrmx+lvFJp9odSO2+97GII3f++3itbMJIjLtpgn/y2/25nMqGXb2lu+tvyeFPnNxV86oG9kE/1VsfcKWAgAAAIAAaE7fgVfLjhSXtrvKsErGmlk+p9Kwvp6Uz6l087FS3GOMqcXHpK9dcWt7tksPOStl7UM+p31rFfeQb+JYkNpVcrtsc1sp7qnFx8qKte6Vz3Hri5vbMifHb23MtjLnK8dogrPUSpmGVRpWnZrzeTa3ZcsmjzObVh6qKT/k2l5e4ZZw8wq/oMuYmpFt1wAAAAAIQku8XXn1xSKdyF87rV2lrp1R6OXcqvl128RgGxEl/vgG/fq732kPLzndbyv0an3r2dxToqcvClv/3KATA91B5K+VK65a2k/Gn1SST9omLAnP5uiMtUTXfrb4598fbLkK1sZPjjJorOe9/yb/Khy5W2bTcuaUXVL3e/1PfioQEVFhcb9fOa3Lf/rqbtYI8pt9ybfXS34YCnOLlbtJyQrgrPCncxKdsQpO6wAAAABh+cNxK3D4nPqXGnt/qy8WiXzfI3h64NyPdxZf0LkzefplbvFV5dypVHD5Ttqyn5zppNMJooZxXdqy19qcKX+lvlVKvb9zh05t6NvTb8XPnZwwNnwPgfNxJTOxgL1aAAAAoJ60xNpe99sKvbxy75l2Vbj346Jt7c2X1Q1p9qXcLS90+8k5/+4blacv6d23zr9Li09fye++FUz6+bgsSm4/nbKF950eoF+ss7q0/+DnNy9aGV6ta19t7cRGNgp+1fnLqU3hHie/+734dzvj1sIeEbVdfHf/UuhTwMH1T1yMz1/yPHpbWt+Q4+dDVg4AAAC89rTG2t7phem3xm9VpJEficg8JVCaXbvylIh+lO4RU/4Zm31JRFdubczRy0Uimi1Js0S2owNiOUSU+EubvLrf/5e2BOkfyFP+zvkvzNWvRGdsca5AqRSZRxakkV8y4+ez7cYJhpENmo6lrp3qGylJRnuUwYS5vpVS2mLZ0l2bPtxREqpIq9ZXYjn6kY5SHyUW3tcOnfwWI3njjz9Jsy8NCaQ32bJqW/Z//SR9d4px/mJi8PyNeyVphMs/HUt5yR9s89Dfk0R240afJJkNICVvHnGhtTL1T2DdDwAAAAhJy5zJbVRK47HbnRumxwKiAkMCAAAA0WiJndxGJpG9QXfwXuADU7g931+f13oDAAAArxmtsJMrjTSWM8WmbduNqYUN7UOj6XlcOOwTDNOKAAAAAAhHK3h7kbyHY6BZ9AQAAABAK4GdXAAAAACAVgbeHgAAAABAKwNvDwAAAACglYG3BwAAAADQysDbi8zykPGDrtLQsji9a6oaWJQpgytvF+xDdaoreGaPekGdEFo1lKnr0S8RhwSoI4d6fx3fzSseWphMAGho4O1Fpuc+Y4xVJpNEM73cNNdzn7HKZDK9xNij0Y6QQpeHpInOCmNsKR2mjDymhqyIaHlI6p0JXQpEIJSp69EvEYcEqCMten9haAHQnMDbOzAX0ukkzfQGXcczqE51mf8K99xn7H4PES3PzdCFeAcZvuT9ngCSeu5rPmdIeu5HKRUZvr2tjdmbZpODmDpU5gAqHGnnApNo/eh1d/jcNeYwO1o8h5Z72AMAGgh4ewen8/qjpTSpY3KoKa667v4HuVr+vn5qNRii9rY4oZrcdPbZH79VkkbWxreMhK2d2EhJurUT+R3ipdm12Ox+dI1WN6SRku3vAMpEJVo/epVqulFBzakzAK0PvL26oP0fb9vQ5ahOdTki+fRdnpleLTZveUiSurq6tC2SmV4tHx8HY0nglxCtCD/B3opZRJdvldauLEFGTkt5d3WaMu6cwka6MzjaK8qsBwOZ33itlbqN6UoXNYQ3w9Ay2T7rVWtJDvUcLQliVc1WziZ7mFpsn8D94sRjSLiNFrwhXjq3Zb84o7xD84vPtOvSP36nd07kvzjr/w7xwr2NgsdXicHzG4NtvqV96Y6xwRNyt8ymE2w6wabPKNFleeKjf8B+dA1+YSmXNOco5eYHPtTXrEmY6B5CrsEfabYh8hv2AIAGgDHGGHv+/HmhUGBNQiNpW5lMT1b0T0kiSk5WmBm3ZyQn+SxmDqL0EjMj9NJLHomsMpm0CdAkL6XJlKvlNmrkdEsSr4aZYSltCCZDZUucuzozhtCR01EVr40wg6GAO/OkGaWopy+lRQ3yMibfOltDXIlONSidNqvmTGXVMSnUwduqwt70MrWPfYL0i1MzjyERwGjeDfHTme0qud18rpx3fmaMsXxOpWHtz0zcVYbNRJWGVWXFyL1S1lLk4p6jDoGclTINq0pxW3bKZ2ylLBf3GNvL5LZVI00tPraEbxqlbmoZOJVuGkU85Xvrb1KzH4V3ikeHWulLjlHKzw9LaSOVky1MdA0h9+CPONt4DHsAQMMAb++AWN4e4+ZBy9uzZl09e9LDFfBMdJ3XSE5WbM8M5jnD2id6snwf6zng8sA8qxP5ai6M0r7ejDCzI4OwRV7GXEoLNBIm1jS7ke7zvApqVWFdzMOANTML+8VDLadxhEaLNjxs7Cq5Xba5rRT31OJjZYWZ3l4+x/ltm9vyTcv34j1CJ7qvZuEpZ6XMO39WHsNrJK5GZ57NbTm3a8h/nNm08lBN+f76sxCd7jf4a0pjjmHG+2dCD5//F9L71vbLU2u28bqbAACNAXZy64m5obtopDgj8TriF4i+L4c70OF4zj4a7aguzqr6cQ4/OpTBpDq7WCVa/nL99lJ6ZmKqStWpuc7rwuhudb0qrs4zJ4e2/TM3EOg4ce3MIkN5GVMY7hg9BrJj9FFlMjnTK9q+JAptVSECA9bO7NsvXkPCZwRGHB4O2k/Gn1SST9omus2kZ3N0xtqTbT9b/PPvD7ZEZWvgJ0cZjKW0T++/GePKyN0ym5Yzp+ySut/rf/JTgYiICov7/cppXf7TV3ezRpDf7Ev69fc1o4SX/AOgGzDUnVIbqxeJqutqsrPDK5GC3NrRZxsAQCMDb6++dIwWJ5M0M2ZEtnTELxDNzNl9htATp+s5G9Rp7Bi9nVbHvlxenqOBnp6BtDr25dTieqfiX38oV0RjeUgeu7AU8JBg4MwOQ3kZsyN+QWyiCA3RC48+YowtpcWhmNGsenB8m+M1JPxGYH0a0pb95Ez+kxrhekdLW/aaQ5+27F9pbpVoa+cOncq2a4lvxc+dVPUgP+3P8PAOj1B3SiC0XpQlSZJ6aUn34ISJwW7tyLMNAKCBgbd3QKrrjiWkjtFH/L/sPdf54xvVqYmZ5GSINSBdAveCl+Whrqkq9QwEPAXcM5Cmmd6Jzus9+uex9QHftwAKq6tFtfy9+Tyouajmk9n0SpaHegWG8jKm1kguLH5IN5ErkXtwVRdnPc5BTk1phXruL6XFT7nQVj04NfvFa0j4jsD6NKT9dKqdvz49QL9YZ3Vp/8HPb160Mrxa177a2omN+Jx4qCmnNrYTFd3vxb/bGbcW9oio7eK7+5dCnwIOrr+AUHdKMJaHesnYODV9SFFikFv7YLMNAKBx0eaDRoqEq02DaMu/dsoRp8Kd0rBntHZJfF/GZYVPawU4/9EnxEYcLrOU5uPvbZ+NKpZMXYTV+eTkazG+SKeTAmXM9vInALjMk5NJomTSQ7zQ6sI4KFu6INFqjFG103o+/RrKqhV3F/sYMEhm4TAQ94I9o5fRgjVErLN5ZEELfTMvjUMbXqcZNt2nH/YyN22nH7wORuhyjOA8ZcWSJhf3rKA9gRyjoBGxZ8KdAjHye8n31J+nZj8K7xT+7vCX5gjBswnkOkmYyLxvbb7iCLONcNhrAcw+9zIA4OiQGGNE9OLFi4cPH16+fNl1RzcizaUtCER1qkseu7B0HC+MBaCJqU5NVUdHe8yrLnn9NrteFiTi3gLg9QU7uQAA0KxUpy6NzVrRBtXFWZq83iFKhKsHwOvMH45bAQD0hT2VSO2VCMt7TYI0cuQ/VNGQsOnjPKDSMVqcnJVlaUy7TE5WHo12EAkTAQCvL/D2QAPQMfqIjR63EiAcx+vlAAPhzYM7CgBgAzu5AAAAAACtDLw9AAAAAIBWBt4eAAAAAEArY72B5bg1AQAAAAAA9cc6pfHw4cNj1CMUH374YRNpCwAAAABwjNjO5DbL+4q1lchm0RYAAAAA4BhB3B4AAAAAQCsDbw8AAAAAoJWBtwcAAAAA0MrA2wMAAAAAaGXg7QEAAAAAtDLhvL1CnyT1FSJUU+iTJEmKjeNn1AEAAAAAjpRw3l5qIa9Eqia1wJiaiUUqCwAAAAAAIhNhJ3d9PCbxK3Ul/dpa9nOnuNFW+/g8ZoomuDQek6RYzF4XAAAAAAAIRXhvb/Fu+QZjjLEb5UvjJSqNX9KvmRq/01cgQYqbQt+VRVPgFS1PakErlI+V14gokS1m5ErsBpcEAAAAAABCEt7bkzMTqXrUrOSZwUKKuKU9yw8kUgbqUpeD1Q1ppOT4i83uE1Fpdk1PuffMVexZn5GtLhT6tBXL/fFbJWlkbXzL+GJrJzZSkm7tRF7OLM2uHUhPt30OoMxhoy0kH2DxF/Y/EI4l+YNg7QmYK/6G9EZf3K+rnqXx2EHk6LpwWyS+uyyB9EG/0IH7xd4xxpVp0EY3JWh+NH/r+fPnhUKB1cIWtSdnVG0BLyPrKYYD50qxldPSrDyaIPNaURQiOaPqCUpeL21UF1xbP1bKNFw2/M29zE1VLu5ZzcyplNs9kPyaqBnZ8nd3lZuPZaNGtViWb5q6eZLP1c4TnZUyZ5Bd5ea26pc7CvXRP6+QkmdqRskcREHYPyJqRuanAe4/uCgaKbJHL3p/E0b6wbQLVsfB9fSWHUL/vGLNl7aZJlrN6Bc/2WH052cqe8ccuJsAqEE4b69BEGm7l7mp0rBKwyoZj0a1+JiGVcrt6h+GH2c2jey6t7erDKvKSm1vz5BgS/eTv7kta/mHH2eKZee3hpdisKvkdo2nL//ZUEYXZSbuKsNmokrDqrLCt0ulYVtzPOWslGlYVYqmqtzjX/c29jI5y88wjSAX96wG6tbmVDJdE0/53vp7wv3D4J65D+7twf418LW/kSXy44r7309UhehpzSlkf2YKZDjPlvnracqQM6r9gtWwQ3A9eU3lTMYsZ+S2y/HS3/5/sO3KcL7tE01Y0C/17hezQ9ze3WH6pAC0ire3q3B+WD5nPdjyOZVuPlaKe0x7WNofhF6POq+1PXe6WP7mtmw977Unq2MdxXGr7yq5Xba5rRT31OJjZcVad8nnOL9hc1vm1nj81mZsK0O+cvg1Tr6UaR/HqhKfZ3Nbtmxu96Rryg+5tmSbCPmFC416eHuwvw817M/Ywfsg1BqSTQVugZGp+bxq5eHvsXC+KF8jd7PWsENgPW0LoXnF7UWIvBOR/nar2/PkFaHrExr0i6ccT/39+kXNyIoicMJ5ewFQf1ri7cqrLxbpRP7aae0qde2MQi/nVs2v2yYG24go8cc36NffudMeJ/LTZ6K9UMaOU37pH/uVd04WB9uIiOj0wuAJV5G1csWV1n4y/qSSfNI20W0mPZujMxu6HKL2s8U///5gy1WwNn5ylMFYSvv0/pv8K3LkbplNy5lTdknd7/U/+alARESFxf1+5bQu/+mru1kjyGz2JW9nL/lhKMwtVu4mjdChK4tUOYRTO7C/JzXtX+iTkuWBbCKi/PD6UH7DrC2RLfaXH2hBTwmaS1pqRic10T9/u6BVdnu+Xw9VDjsOvfQsPSj3qwspo64FxjYi2i6RHSjrelJpfC7uiqk+jDvFE/SLgV+/JLLF+AblF1LOMp2xI+0t8Lrxh+NW4PA59S/eN+zphenThyk/FG3ZT8500ukEUcPc8m3Za23OlL9S3yql3t+5Q6c22rXEt+LnTk5cO3toD/vzcSUzsXDYzgTs74Wv/Qt90pWNjMqOzNfzpjQeuxNX2YKmSaGvL7qoRPYG9RUodX78Dt3Y0Jt2NOMwHKmJeN94KZVNFG6XBxZM1QxTrPVJsfHzUZ2WOoF+aSjVwGtKS6ztdb+t0Msrxinawr0fF+nEQPexqZP4S5v862+X9FOZz/pmX7qynI/LrjQiaj+dauevTw/QL9ZZUdp/8PObF60Mr9a1r7Z2YiMbBT+N/OXUpnCPk9/9Xvy7nXFrYYmI2i6+u38p9CnU4PonLsbnL4U9sqadJAx1FhH2F+Np/9J4TLoTV4VLIBHsH5TUAN3h1Ck9KMcvJohorUz9F3VN+Jc8aWysWy8IDaBWaiI+Nz5uLSBR+HHopadDTkCFPPTXlpHsC0iFvmT5xkY2QZRaUPvnk7x09Mvx9YsvpfUNOX4+UFYAoqBt6DZ53B6zndIwApVsRyv4qHYuaM8et+eMXueOVvBf6Yme8hl/SqOct53/1eGCV0zJmljz0jg04BVNv+mOvueN4BeYr8sx7KCsWNLk4h6z28d5gEAr6Ipr5E4hGPm95Hvq74c9Ilo3nk8UuZqRg0Utwf6R7e8XZR/Y/j6CnN1L9qAqQb1WspzJKLav3O8OCKKWK6/IDuH1tH/hfpmBoISP/vbz0IZkex/Z6kC/HEO/+NeLUxrgsJEYY0T04sWLhw8fXr58mZqB5tK2cK905ZeT6hf2jbbSeOx254YrdgPUi0KfdCeuHvMW1msM7H90lMb7HlwMuJOJfjk6wvQLHgjgsHkN4vaOha2dWPY34yTGify0K6Yqkb1BsfFSCrPu4VCYW1RuIFzm2ID9j4LSeCx5V5tm7vZ1sgC+AvrlKIjQL7fn+yeyh6wWeL1phbU9aaQ5XkLOpsWTbLPof9h42eewgf01jsv+AAAADptWWNtr9qdUs+vf7MD+AAAAWpuWOJMLAAAAAAA8gLcHAAAAANDKwNsDAAAAAGhl4O0BAAAAALQy8PYiszxk/DCjNLQsTu+aqgYWZcrgytsF+1Cd6gqe2V5LqFIi9WzKNzl1bEtrmEXYilBNi2YH/1IRtDrM7gh/94HjpHZ/NdTNe/B7EAAieHsHoOc+Y4xVJpNEM73cjddzn7HKZDK9xNij0Y6QQpeHpInOCmNsKR2mjDymRq1lZiKgS8oXDKFd87A8JPXOHLcSDU8oKzWISQ9TjfB3HzhOavdXgwxajYZSBjQ52k9qNP8vpx0Xlcl0Op0kouRkhU9NppdqFUySK89SmtyJgbRIhigYtRa+YLgajxihbQOWq3ujoirTWHCtqG2lUJnrpFXtjIemRkPfC8CFuL+ObNB61+v5PUYXqANY2zs4ndcfLaVJHZNDraxX193/YFbL39dPLe+ao9ZyNOrVAZFtj42GUiYyoVpxZE1uDdvWZH/8VkkaWRvfMhK2dmIjJenWTuTXgpdm12Kz+9E1Wt2QRkq2vyhvUYYAACAASURBVAMo0xgc11hqojGMcdjkaE5fI62W1aaRtK1MpicrTP8PzPwXzL62p31HROYKIL8Tml5iS2miZDLJdUtyssKvwFkS+CVEx36q6P8/Z9XctUOYI7dTnLPgkvkfp6mn9sHIaBZ37vq61bS1jqtIy6knpJeEdnBX6rCtuxbd4JYY7cqoW9CEQPU60DJ4KeM1MFzpIh34FvAtTi+ZKwFakpkgVCCAQYSt8LSSu799MouHtN16XnYW2ta6XwTD2HOBRNgFNTvX2U4ul1tgcDv71Lir3Hws53a1C7VYlm+W80K1OPK52nmis1KWi3vGxa5yc1utdw019RfNV56W9J0t6zFol9K2CYy/+QSDw2uyEs9/HreAd3t9Zt0aU4epgOi+xDhsZuDtHRDD2zNu06Th+/E3eJLPkrS8Q/N2td9v9kRWmUzaBGiS9bmFMTO3cG/Ct2rv7Lx0WwbHZoepp/sxphW3P4MFE4iodfashjHdOT0q9X208/3CzY28M+loQuB6LYR9Gqx3eMVsOrgS3d2RNqd4rpVWHZNCd9PbIB6tEFvJIdU/s3hIu6wntHOt+0U4jL0371xdULNz7T1ju/sC9Km3nX1r3FVyu8ZTh//MGGP5nErD2p+ZuKsMm4kqDavKipF7paylcM9IbzkrZRpWleK27JRvPmX3Mjnr+aoWH1vCN41S+gOYU8l8JHvK99bfRNDRnpasPVsecNA6/EBdEfe85D8yPW9zj1sg6qzrN3XwCxLueQvj0GmRJgLe3gGxvD3GzSOWt+eIkbM5NK4wEWGi60REcrLivImFD7MgVYswKgzi7fko75rgbI85Z2W21jkiBNNmktAOwkrFDeTU4TPpzp5YWvB6hbbyUsard5bSgtlZmFhzCBnpPp0d1CDCumq2PZRJa1rP3b9eFZkGNmVHvkE8Gyi6+7wERht4NnaV3C7b3FaKe2rxsbJirTfkc9zzcnNb5tY2/NYkbCsivnJWyvxD18pjPK3JsZrC59ncNteB8rnHmU0rD9WUH3hNxbOjhbMQ8xgMdRy0XhJqKhzoNve/BYLNuoGnDldJjMMmBnF79aTnfmUySTO9Q4tGijPUrSN+gej7cvBTsETknFcejXZUF2dVuhD3PfEboerqVJckSXMDdTl0q65XiTqUwaQ6u1glIqquq8lOgcqu1hFRz4BxWnj5y/UB42izKKegUm8sdZa/XL+9lJ6ZmKpSdWqu83qPZxPqUa8br94RxkZGD5jsGH1UmUzO9Hq9ayekQYSEantwk0avK+AwDnyDOCv1uvt8BEYceA7aT8afVJJP2ia6zaRnc3RmY7DNyHC2+OffH2yJytbAT44yGEtpn95/M8aVkbtlNi1nTtkldb/X/+SnAhERFRb3+5XTuvynr+5mjeCq2Zf06+9rRgkv+TUJ0NHqetWzvwJzwEFrSfBXONht7n8LBJ51a+LzvMA4bE7g7dWXjtHiZJJmxowz/h3xC0Qzc/bnbOiJx3WDB3EaQ1e9PCSPXVhi7H7wB31tOkZvp9UxWZIkqZeWhBOkcPrquT6ZVMe+nLI9EEP7VB7qfLm8PEcDPT0DaXXsy6nF9U7Fv0MOXq9bEY/e6YhfEHd3ZB06Rh8x7V07vQJ/L5pBDs4hmFQn8DCOfG963X1+Autj57bsJ2fyn5xNhCp0uLRlrzn0acv+leZWibZ27tCpbLuW+Fb83El1OsGsP+PJGplwHR36X2wBBxy0tRQ+0G1ul1R71g2Gx+2AcdiUwNs7INV1x/9jHaOP+P/beq5rq33aI6A6NTGTnAyxbqJLmOk1X9S8PNQ1VaWegdqngENWXS1/b86J9Tt9uzzUS8ZugGiWE7aOSJuwaGbMWtjzzBmOnoE0zfROdF7v0T9zVYgL1KdekVhR72j6mR1bnRrSu9uVyD3Eqouz4oN91akprVDP/aW0+IkX2iAH55BMSkShhnHke9Pr7vMVWB87t59OtfPXpwfoF+uMJO0/+PnNi1aGV+vaV1s7sZGNgp9cfzm1Kdzj5He/F/9uZ9xaUCGitovv7l8KffrST/8wHR1gtqzJgQdtbYWFt3kUas263lOH+c/K8lCv3+2AcdiMaCOikSLhatMg2lqBua74hkqNM7mO0i6soFkrjM1Vk2AzQByg4SFJGMek59XeIehVGxfT60I/rmtU6VTS6wCmSKWK662FjpxckLKtUrPVwoC1pbTt6Br/WSgteL1uPf2VEQ4Me3X2g6KORKsao7+chvQZo6EMUnEPV6+2M9HYrmlSj14WFOetIKqoIhjG3Lc1u6Bm53opaR3U8CgUYeBpmKHiWsiReWkEy3tFkW+6o873MjdtUedeAem6HCMoSlmxpMnFPStYSiDHKGhESplw0fdGfi/5nvqLu0DQ0T7jzdZfJnUbtOlJSxL3WTwyuTOwmkTHbS4cG25Cz7quqUNXxHo1hGCmxjg0hfNnsJoGiTFGRC9evHj48OHly5c9h1Mj0Vzavt5Up6aqo6M95lWXvH67vnvFAAAALCLNutWpLnnswhJm55YFO7ngEKlOXRqbtbYPq4uzFHIfGwAAQHAw6wIhfzhuBUAr0zFanJyVZWlMu0xOVg4QMQzAa4o0gh8IICJi0410MKBRiTLrVqe65DGVSO2VyHt5D+NQo0nHIXZyAQAAAABaGezkAgAAAAC0MvD2AAAAAABaGXh7AAAAAACtjBW3d9yaAAAAAACA+mOdyX348OEx6hGKDz/8sIm0BQAAAAA4RmxvYGmWU67aSmSzaAsAAAAAcIwgbg8AAAAAoJWBtwcAAAAA0MrA2wMAAAAAaGXg7QEAAAAAtDLw9gAAAAAAWpkG8/YKfbFx1+8ul8ZjkiAZAAAAAADU5A+1sxwlqYUNd2IiW8yUHxy9MgAAAAAAzc+RrO0V+iRJkvoKpfGY9oG0BTuNvgKfi1/E01IkqQ+uHgAAAABANI7E20stsHwmM5FKZIuZTJ4tpKg0fql8gzHGGFPjdzR/L7XAmJqJmaUKfXfiqpZj/q5gyQ8AAAAAANTkqOL2Up30oESF2+XOVOiyiewNpc7qlGbXpJGSNLJRqLNgIiLa2omNlCTuLza7fxj1+GPEQO6P3ypJI2vjW3b1bu1EjoQsza4dqEWrG5LdPgdR5pARRpICAAAATYW2wPb8+fNCocAOk7xCJGdU41LNyLoGSt783kRLsyVxZeuh7V7mpioX9w4mxIddZVhVVqzPh1mXCDUj64ZljO0qNx/LuV39m2JZvlnOi4tZ5HO180RnpcwZZFe5ua365Y5CvfS3GRIAAABoQo7ulEZqgaW4y0R2g2V9vvdI8mR//Fbl7q9ERPTOSfWLswmi0uxacvUVnTujvvtLcvUV0RuZ8fPZ9rrK2dqJZX+rEBG9kel+4+7qS1EtpwfO/Xjl5/8h+p++kR8XiejcmTz9eOUpcZmf6V8REZ3IT8f0hlvyiYjo3Bl27bRfukHh9t3YALOuT526QS8KdDpFz27//PaNUy+snPdKV5466jWUGSldISIiZTCx0E1ERKsb0uxLIpK75Y3BNluNbjmrG9LsS6X75MaqpirXLtPa9367eO3swhdEpp014X/5TW+g3gucfYx+8Zbvrb8nhT7pii5fzqgb2YTxRSJ7g2LjpZSVAgAAADQZmtN3BGt7dcSl7a4yrJKxdpXPqTSsr+vkcyrdfKwU9xhjavExWWtIwrW9kHI2t2Vr0W5XGbby29b2Nrdla51PE6vnVIuPKbfryKAWH9Pw48ymXYhNf690E8eC1K6S22Wb20pxTy0+Vlasda98jjPC5rbMyfFbG7OtzPnKWSlbNuFLrZRpWKVh1ak5n2dzW7b6QjOIUbam/JBre3mFWzrOK/xCMmNqRrZdAwAAAM1Fg72BJRqrLxbpRN5Y3EpdOzM38uPcKqW6tYS2icE2Ikr88Q1a/X2NyHORJqQc+sd+5Z2Tqr7EdXph8IU0a5O3OFvSUlxrS8Yq1OB5RlSaXasQVYzMGuX/Jmp/K/4O3TXTz51hX2i6eaWbrJUr1OloXfvJ+P9XSdJJdZDWvtOSns3RGWuJrv1s8c8bD7YoUWP5042fHGXQWM97/83YrlVG7pY3Bmn83m82Sd3v9d/6qUCxFFFhcb9fOavLf/pq8WnpLt9Cox+95IehMLdYWVyUhPKJEp2xypzfuAEAAAAampbw9vw59S/1eUyHl+O5gXju7ZQzyb3LSURt2S8SWXOT9OmP0q1/ql+cTXim+9OW/eRMJ51OEK2FbMih0Za91uZM+Sv1rVLq/Z07dGpD9zvfip87OXGtZgMjcz6uZCYWsFcLAACgNWmw39KIRvfbCr28cu+ZdlW49+MinRjoDiGgcK8k3XsWVk7iL23yr79d0k+nPuubfRlJe0r8pU3m6tWOrPataodnNwpEqWsJNp1ggyfo19/XyDvd4nxcJgHtp1OOgEL6xTqrS/sPfn7zopXh1br2lVGdN/5yalO4x8nvfi/+3c744n6/Yi5Ytl18d/9S6FPAwfVPXIzPX/I8elta35Dj50NWDgAAADQMEmOMiF68ePHw4cPLly8ftz6BEGnLna4w1snMqH86d4Yp/+Sj/sn8ykQ/6BBOTsI6LXEiP0hXZik/HUvZj1DYDjQYpxyc6bZTGm7hGsaRDq90jkKfNDfAFlK8ZC2beam1zlavbTGSb5q+7sgbx2YiEsoxGqsMJhbe16XJ3fLGH3+SnJ6xfWlzdUP67m3nuRPrFIiR30u+ZlWB/n5wxzSISMlrxtO+ia1PbGDlDwAAQLPSMt7e8VO4V7ryy8kAO6pHQmk8drtzw/RYQFRgSAAAAM3OaxC3d6jYltlO5Kcbw9UjvDikXhRuz/dPZGvnAwAAABqWVvD2pJEG+bGDl1eMF7wdC2za5tmlFvSfm2sY+xwzDvsEw7QiAAAA0Ky0grcX6Sn+GgH7AAAAAK8zLXEmFwAAAAAAeABvDwAAAACglYG3BwAAAADQysDbAwAAAABoZeDtRWZ5SDIYWhand01VA4syZXDl7YJ9qE51Bc/sUe8hc5R1vc4I7RzK+NF6yr9UBK0Oc8BEvF9AHTnUCeFwhIuHDWY20BzA24tMz33GGKtMJolmerm7vec+Y5XJZHqJsUejHSGFLg9JE50VxthSOkwZeUwNWRHR8pDUOxO6VDSOsi7gIJTxG6SnDlONiPcLqCMNMszCgGEDmhx4ewfmQjqdpJneoOt4BtWpLvM/wp77jN3vIaLluRm6EO8gw5e83xNAUs99zecMSc/9KKWicZR1veaYY8kcYEGMHyqzf70BtfIvcpgDJuL9Ag5OtGHGj5kg6VRrNEbCc9gIxzYADQe8vYPTef3RUprUMTnUnV5dd/+fWC1/Xz+1wOuNaIDVJ/NBOLKKjpf98VslaWRtfMtI2NqJjZSkWzuRX3Reml2Lze5H12h1Qxop2f4OoExUovW+V6lGG0uNpg8ANuDt1QXtX1Xbhi5HdarLEcmnb2TM9GqxectDktTV1aXtFMz0avn4cBBLAr+EaEX4CbYYzCK6fKu0dmUJMnJayrur05Rx5xQ2smYYi9sg3lXwYYxu0XokjSnQEKena4W1IgIbcnroYt0pATT3KmdPNBoytEy2zy5VvXUI0qeaGR0DzF7c2bKAmcWDkBOi5RX2o1Ara4Qf1uBxq6hhu1/cAoPb2avGtuwXZ5R3aH7xmXZd+sfv9M6JfK0f0S7c2yh4fJUYPL8x2OZb2pfuGBs8IXfLbDrBphNs+owSXZYnPvoHHGaukSAs5ZLmvIm4yVM4gYhnlQjTLHmMbQAaD8YYY+z58+eFQoE1CY2kbWUyPVnRPyWJKDlZYWbcnpGc5LOYOYjSS8yM0EsveSSyymTSJkCTvJQmU66W26iR0y1JvBpmhqW0IZgMlS1x7urMGEJHTkdVvDbCDGZz3AbxqmIpbbSLL2Y2g/hSegKnr9VikQ1taZMuS086zenVlbxtbWZ0JXLdp39Ou1QNoIN3nwrHkldHC3sn+KgQ9ITHUKk1woWDR1CLVxcEGJ+e90uAPvW2s2+Nu0puN58r552fGWMsn1NpWPszE3eVYTNRpWFVWTFyr5S1FLm456hDIGelTMOqUtyWnfIZWynLxT3G9jK5bdVIU4uPLeGbRqmbWgZOpZtGEU/53vqb1BxmIUYCl+683/nJUziBCBOjTbMedxwAjQe8vQNieXuMmw4sb8+aWPTsSY+HsWei67xGcrLi9H08Jhr7XGbm0J09V3XmzCuszpVThFHa258IahDX7G975no0XCiN+TXKJtKd4mybSPOltMAewsSanV5Th+B9KqyLeXRfzcxCAwolePajr1amgU3ZwiEdavB4WM1W0EtgtHvHxq6S22Wb20pxTy0+VlaY6e3lc5zftrkt37R8L94jdKL7ahaeclbKvPNn5TG8RuJqdObZ3JZzu4b8x5lNKw/VlO+vPwsxJmuPBB9pzDEwXBOIMDHyNOt1IwPQYGAnt56YG7qLRoozEq8jfoHo+3K4Ax2OR8mj0Y7q4qyqH+fwo0MZTKqzi1Wi5S/Xby+lZyamqlSdmuu8LgxgVter4uo8c3JouyBzAzWOEwc2iLpe5RtAVF1Xk501WuxjXnejOkYfVSaTM73WTo47JYDmwmDL6BGYvjpQ6D4VIui+2plrj4rodR3K4OELetwvPgIj3jsO2k/Gn1SST9omus2kZ3N0xtqTbT9b/PPvD7ZEZWvgJ0cZjKW0T++/GePKyN0ym5Yzp+ySut/rf/JTgYiICov7/cppXf7TV3ezRpDf7Ev69fc1o4SX/AOgGzDgSAiKcALxmlWiTrMANAXw9upLx2hxMkkzY0aAR0f8AtHMnP2pHXr+cD1KgjqNHaO30+rYl8vLczTQ0zOQVse+nFpc71T86w/lDGgsD8ljF5YCnIMLaRCtAbIkSVIvLQVzMcTShI3qGH3EGFtKWyGX7pRamnfEL4g7KIIZvbSyfxulTw9O5ObU5LAGj6Og4H7xE1gfO7dlPzmT/6RGuN7R0pa95tCnLftXmlsl2tq5Q6ey7VriW/FzJ1U9yE/7Mzy8wyPwSAiMcALxmFUiT7MANAPw9g5Idd2xiNMx+oj/r7TnOn98ozo1MZOcDLEKo0vgXvCyPNQ1VaWegYCngHsG0jTTO9F5vUf/PLY+4OszCaurRbX8vTkt1ljWCmeQ5aFeMvZGPB8B5uN6eahXLE3YqOrUlFau5/5Smr4vi1KCaK6ZmIs7H9I7yJXIPT2qi7MeBw19ddC+CdunByfSqAjIoQ0evqDH/eIrsD52bj+dauevTw/QL9ZZXdp/8PObF60Mr9a1r7Z2YiM+Jx5qyqmN7URF93vx73bGrYU9Imq7+O7+pdCngIPrLyDESAiKcAIRJR5smgWgCdCGfCNFwtWmQbStcG9fcoRrWHF7jozWZgFf2oUVvW8dVnDVJNjqEEWNLKX5EHPbZ6OKJVMXYXU+OflajC/S6aRTGXtUu8AgXlU42ygMF0smkx7ShDrwkVm1Unz6XBhoZEsXJFrtNKzkrLC2DsH6tOIeYD7dFySzcBC6WioozltBVFFFMHi4b2t2QZDxKVTSCuPyKBTh3tEwjyxooW/mpXFow+s0w6b79MNe5qbt9IPXwQhdjhGcp6xY0uTinhW0J5BjFDQi9ky4UyBGfi/5nvp79J3YgMJpxCzlnmWFHcrfBcIJxGtWiTDNCu84LXJbeFgIgGNDYowR0YsXLx4+fHj58mXXwG5EmktbcACqU1PV0dEe86pLXr/NL/JVp7rksQtL9X6TKgCgFRBOINfL/rMKAK0IdnJB41KdujQ2a+1lVhdnKeQ2OADgtUU4gXRgVgGvJX84bgUA8KRjtDg5K8vSmHaZnKzYzmlUp7rkMZVI7ZUIy3ugkZBGjvyHKhoSNn2cB1Q8JhDfWQWAFgU7uQAAAAAArQx2cgEAAAAAWhl4ewAAAAAArQy8PQAAAACAVsaK2ztuTQAAAAAAQP2xzuQ+fPjwGPUIxYcffthE2gIAAAAAHCO2N7A0yylXbSWyWbQFAAAAADhGELcHAAAAANDKwNsDAAAAAGhl4O0BAAAAALQy8PYAAAAAAFoZeHsAAAAAAK1MOG+v0CdJfYUI1RT6JEmSYuP4pXAAAAAAgCMlnLeXWsgrkapJLTCmZmKRygIAAAAAgMhE2MldH49J/EpdSb+2lv3cKW601T4+j5miCS6NxyQpFrPXBQAAAAAAQhHe21u8W77BGGPsRvnSeIlK45f0a6bG7/QVSJDiptB3ZdEUeEXLk1rQCuVj5TUiSmSLGbkSu8ElAQAAAACAkIT39uTMRKoeNSt5ZrCQIm5pz/IDiZSButQlYH/8VkkaKUkja+OrO7FbO/VdOyzNrkkjJWmkJN17FiSdp9CnrWRqGq6NbxlfbO3ERkrSAVQtza7FZvejliZa3dCVN//qbbc6oi0wH2BRGPY/EI6l+oNg7RWYOwGG9ONb9Nf2HmzVl8ZjjbwJoduM2zrx3X2pDfqlPtg6xrgyDdrQqoOmQvO3nj9/XigUWC1sUXtyRtUW8DKynmI4cK4UWzktzcqjCTKvFUUhkjOqnqDk9dJGdcG19WtITqWb2ypjjO1lbpqf60w+p1JuN3g6Y4ypGdnyg3eVm49lI6daLMs3y3lxMV547TzRWSnLxT3jYlc5BLvVR/+8QkqeqRklcxAFYf+IqBmZnx64/+yiaKTIHr3o/U0Y6ZG1O9DwOkC90ckr1jxqm2miCUO/1AteZXvHHLibANAJ5+01CCJt9zI3VRpWadhy3dTiYxpWKberfxh+nNnkMov9LU6OVWRX0S5zu/mcKhBlr9ckgreneSkGu0pu13j68p8NIbqSZqKhp/GnrBi5V8paCucreMtZKdOwqhS3Zad809vYy+SsxhrmVeXiHts0SunW4FQy7eMp31t/T7h/JNxPmIN7e7B/DXztb2Q5wHPb/J9QVIXIq+AUsj8zBTKcZ84C6GkVUfLc8DKS/fRRFENd73qFeuYVIlIyrv+qHSXkTMayh1e/GM63faIJC/rFzF6nfjE7xO3d1cN3BqBVvL1dZdjyn/I56wGWz6l087FS3GPaQ9H+wLP7bcy5zqc9FFcYJ1aXrBYfU27Xp14rJZy357jVd5XcLtvcVop7avGxsmKtu+RznN+wuS1zjqbf2oxtZchXzkqZdz6sPKbdHK4tn2dzW7Zswpl3pUw15YdcW7JNhPzChUY9vD3Y34ca9mfs4H0Qag3JpgK3wMjUfJ57RvP3WBhf1CYxIwfwcrgUNSPbPRpRvV565hXLmXDINDPlFVMh337JK0L3JzTol/r2i5qRFUXghPOtAyA6LfF25dUXi3Qif+20dpW6dkahl3Or5tdtE4NtRJT44xv06+/6aY/uGJuWM+8Q0au7WSP+aeu3+V/fyHxyNqHneVuhN+Lv8zWdyE/HUkSJwfPs2ula9UZgrVxxpbWfjD+pJJ+0TXSbSc/m6MzGYJuR4Wzxz78/2HIVrI2fHGUwltI+vf8m/+ocuVtm03LmlF1S93v9T34qEBFRYXG/Xzmty3/66m7WCDKbfWnZ31t+GApzi5W7SSN06MoiVQ7hNA/s70lN+xf6pGR5IJuIKD+8PpTfMGtLZIv95Qda0FOC5pKWmhEpPSj3Fw3xiexGgNdRpSb65/WKk3djnHIeeOup5BdS2qfzcaO/Sg/K/aqRTKkFxrQKAtwXh3GneIJ+CdIviWwxvkGmOCu9M3akvQValZbw9vw59S8ed3Jb9osEm06w8ZPyr/uip/Xphenz2XYu4dzbqcPQsAZt2U/O5E0ftCFoy15z6NOW/SvNrRJt7dyhU4bR3oqfO6lOJ5j1Z3gY9eF83Llu5Joq6wDs74Wv/Qt9knQnrh5Kl4SkNB67E/fcJzxUEtkNo141fqdGxH299PTpF6OKPF05/vB/9EsD3BzgtaElvL3utxV6ecU45Vq49+MinRjo9inwrG+k1LeqX5T+sV+hNzrbidpP9r/z6u6ieVp2f/xWye8QZeh6a3I+LouS20+neKeTTg/QL9ZZUdp/8PObF60Mr9a1r7Z2YiMbBb/q/OXUpnCPk9/9Xvy7nXFrYYmI2i6+u38p9CnU4PonLsbnL4V9ZmknCUOdRYT9xXjavzQek+7EVSZaM4lg/6CkBugOp07pQTl+MUFEa2Xqv6hrwr/8SWNj3XpxqK9aiYvx+dtmhtL4nZqrUc4TlbFOzh7uev31FCvE2d8U5Nkvhb5k+cZGNkGUWlD755N8c9EvnvUeer/4UlrfkOPnQxYCwI32L0aTx+0x++kKPfDIjF6n3K49en1XGS4rVnS8K3TPI7BdFGgvqNcd7e487eFMt+CCQszMjrLGoQGvaPpNd/S94+iJp6q6HKOxyoolTS7u8UZwyTEKuuIRuVMIRn4v+Z76+2H/T1s3nk8UuSiuRwjsH9n+flH2ge3vI8jZvWQPkhLUayXLmYxC4gD8AIFifM1afL6cUb31EQ5Ov3qFehqJSt4qJQr7d8S9OavmxTiv0C8CUUfUL3720b5C2B6oBxJjjIhevHjx8OHDy5cvUzPQXNqGozQeu925gQX+Q6PQJ92JqzUDdcAhAfs3JuiXxgQPBFAvWmInt5VIZG/Ydj1AfSnMLSo38Eg7NmD/xgT90pgUbs/31+fnDMBrTyus7Ukjze0csWnxJNvs7aoXXvY5bGB/jeOyPwAAgHrxh+NWoA606tOoVdvVLMD+AAAAWgPs5AIAAAAAtDLw9gAAAAAAWhl4ewAAAAAArQy8PQAAAACAVgbeXmSWh4wfPJSGlsXpXVPVwKJMGVx5u2AfqlNdwTN71NtUmJq3QBNqJoaScMBSEbQ6zC6IOLDBMVG7v5r3hgWguYG3F5me+4wxVplMEs30cvNXz33GKpPJ9BJjj0Y7QgpdHpImOiuMsaV0mDLymBqyIqLlIal3JnSpRsDUvHmbICRUcxqk7YepRsSBDY6J2v3VPI5hiwAAIABJREFUIIMWgNcReHsH5kI6naSZ3qDreAbVqS7zf9ye+4zd7yGi5bkZuhDvIMOXvN8TQFLPfc3nDEnP/SilGgFT8+ZtAnGdbo6EIM0Jldm/3oBa+Rc5zC6IOLDBMeHZXwcftEcPP/4BaAVa4X17x03n9UdLJPWOyUPxYO4ZERFV193/BVfL3xNdqKtyoOERjYT6ZD4IR1bR8bI/fqty99c3MuPns+1ERLS1E8v+VnnnpPrF2WivWyzNrl2isxuDbRE1Wt2QZl/aUg6gTGPQjGOpEXTG4AT1BGt7dUH7n9W2octRnepyRPLpOxozvVps3vKQJHV1dWn7IDO9Wj4+wMWSwC8hWhF+gg0Us4gu3yqtXVmCjJyW8u7qNGXcOYWNrJnB/NqVpsf9aCpySeHiIH1KibRwJBrWGlom22eXbkJZgY2vmdQxErx6hIxeCJJZPFo4IXzIo6O4UCtrKNbs5VpdUHsgkefAdgsMbmevGtuyX5xR3qH5xWfadekfv9M7J/K1HmCFexsFj68Sg+ejP02JqDvGBk/I3TKbTrDpBJs+o0SX5YmP/hqijva0pO9EVJdBSxFvUt/5xHtyE+ps5u2aqvKZ/dqi1SGe5vQLn4ZjcIK6whhjjD1//rxQKLAmoZG0rUymJyv6pyQRJScrzIzbM5KTfBYzB1F6iZkReuklj0RWmUzaBGiSl9JkytVyGzVyuiWJV8PMsJQ2BJOhsiXOXZ0ZQ+jI6aiK10aUwZI6ueRQSSsyacYqmprWsh5nEA9tuFLuGiseibxY7XPapZugRcGNL+x0rx5xSPXPLB4tzKxcr1fYp7WGorCXQ3RBgIHkObAD9Km3nX1r3FVyu/lcOe/8zBhj+ZxKw9qfmbirDJuJKg2ryoqRe6WspcjFPUcdAjkrZRpWleK27JTP2EpZLu4xtpfJbatGmlp8bAnfNErd1DJwKt00injK99bfRNDRnpasPREddNCyiDfpknA+CTa5CdWwtqHNzMK2eE1Z1tgzHhA1G47ByUC9gLd3QCxvj3GTneXtLaVtt7DQTfFPdJ3XSE5WHHOHx0zB5+Jz6M6eqzp+CnNX58opwigtdlNsKi6lBWIcDalpPWHDvUoJa6yphldd7ha5ZQQxvrAu5mHnmpmF3SeUICxeUyvTwKbsUF0QqIGige0lMNogt7Gr5HbZ5rZS3FOLj5UVZj5Q8znu0bi5Ld+0Hm/8Q9eJ/ji08JSzUuafr1Ye48FMXI3OPJvbcm7XkP84s2nloZry/fXn8Oxo24CpNREdfNAe7Ca1zyfBJjePGTVYW8QDlfvGeGrUbDgGJ6gf2MmtJ+aG7qKRUi1/b8vREb9A9H053IEOxxzwaLSjujir6sc5/OhQBpPq7GKVaPnL9dtL6ZmJqSpVp+Y6rwvDC9X1qrg6z5wc2obE3IDHceKO0UeVyeRMr7WB4bCMiGjW8yolrDGIGmJcLXJ+H874QgR2rp25dvdFr6tGL5vZgnacs1Kvge0jMOIgd9B+Mv6kknzSNtFtJj2bozPWtlf72eKff3+wJSpbAz85ymAspX16/80YV0bultm0nDlll9T9Xv+TnwpERFRY3O9XTuvyn766my1JIyVppCTNvqRff18zSnjJr0mAjlbXq579FZhAgzb6Teom0uQWDHW96jdQewbSNDMxpQ3UAaPiIHcrBieoB/D26kvHaHEySTNjRvhKR/wC0cyc3RkIPTu65p+gTmPH6O20Ovbl8vIcDfT0DKTVsS+nFtc7Ff/6I0x3y0Py2IUl/0PEHaOPGGNLaS2+sSN+oWZF0aznVUpYYxA1vGuytcj9bRTjH5zIzalJkF4mogMMe6+B7SewPnZuy35yJv9JQ8Wbt2WvOfRpy/6V5laJtnbu0Ck9cp/eip87qepxVNqf8RCNTLiODv3fqwDfQXugmzRMRQfHb6D2XJ9MqmNfTtn+EwmkDwYnqAPw9g5Idd3xb2fH6CP+v+Ge6/zxjerUxExyMsTiji6Be8HL8lDXVJV6BtKkjsm1XxHQM5Cmmd6Jzus9+ucx69/K4NXVolr+3pz0xf+IV6emNF177i+l6ftyVdeMi9seclcUzXpepYQ1ChO5h1h1cVZ8OM/dIrciYY1/cCJ1X0Bq97JNjUjD3mtg+wqsj53bT6fa+evTA/TLuLVesv/g5zcvWhlerWtfbe3ERvyDyv3l1MYWtN79Xvy7nXFr7YSI2i6+u39pdj+ERCJ//cN0dNCJyFdIrUEb+SYNW9HB8RuoHaO37YMzuD4YnODgaAvIjRQJV5sG0daK2XVFeFhxe46Mtjhd716x4o2TzvgOnyAUcRTZUpqPXLd9NqpYskcfO6vzycnXYnyRTifdyoiNxVVki+J3Rb7Y6nQ33COoR/Clo0bPRKvNRnOc6vt0fyjjV9wjwcfOQTILR4urpYLivBVEFVUEvcx9W7MLggwkoZLWQQ2PQhEGuYYZFa5FF5mXRly8V8D4pjvAfC9z0xZg7hV7rssx4p+UFUuaXNyz4qIEcoyCRlCUCRdob+T3ku+pv7gLBB3tM95s/WVywEHrVCnwTSqcTwJObqbOooBVovSk1SbuM3eIzK4qZwpH83wajsFpCucPZoGISIwxInrx4sXDhw8vX77sum0bkebSFgAAAADgGMFOLgAAAABAK4Pf0gAAvL5II6XjVqEhYNONdAYAEBEGpwEGZ12AtwcAeH3BgwQ0LBicoI5gJxcAAAAAoJWBtwcAAAAA0MrA2wMAAAAAaGWsN7ActyYAAAAAAKD+WKc0Hj58eIx6hOLDDz9sIm0BAAAAAI4R25ncZnlfsbYS2SzaAgAAAAAcI4jbAwAAAABoZeDtAQAAAAC0MvD2AAAAAABaGXh7AAAAAACtDLw9AAAAAIBWpsG8vUJfbNz1O9Cl8ZgkSAYAAAAAADX5Q+0sR0lqYcOdmMgWM+UHR68MAAAAAEDzcyRre4U+SZKkvkJpPKZ9IG3BTqOvwOfiF/G0FEnqg6sHAAAAABCNI/H2Ugssn8lMpBLZYiaTZwspKo1fKt9gjDHG1Pgdzd9LLTCmZmJmqULfnbiq5Zi/K1jyAwAAAAAANTmqndxUJ42XaO12uXMhdNlE9oYyv15nhfbHb1Xu/kpEb2QG2+b/DxW/OPlASzl3hl07fSDZWzux7G8VLkHuljcG2w4kMzyFvtj6xEY2obX0jcz4+Ww7p947J9UvziYiSS7Nrl2is9FbtLohzb60pRxAmUPGsOJx6wEAAABE5shOaaQ6y0npTnwiRUREiWwxfkfbpk2WbyykSN+2Td5dvJvUd3dTCzfKSS3PlcXK3Uv1PKdRuFe5SyfV6QSbPkv/R/PM2rJfJPLn6iG9/ezG9BmFSBlMsOkEmz4TW63EZvfrITowpfE7dCObIKK27BdnlHdofvGZ/s0/fqd3TuRreVeFexsFj68Sg+cP5Lx2x9jgCblbZtO6fZTosjzx0T8MqYn++dv1EAQAAAAcF0d3SiO1wFLcZSK7wbI+33skeWKu1VkLRaXZteTqKzp3Rn33l+TqKyJzfWt//ReiU/+SINKcPJsi9M/xWyV92c9cD3PLNxfw9Oq4xUKrlMbpgXM/Xvn5f4j+p2/kx0UiOncmTz9eecpnfqZ/RUR0Ij8d0xvuWCY01x290g0Kt+/GBph1ferUDXpRoNMpenb757dvnHph5bxXuvLUUa+hzEjpChERKYOJhW4ispbl3KuVAjmrG9LsS6X75MaqpirXLjKseu+3i9fOLnxBZPaXJvwvv9nNy9nHXAj0lO+tvyeFPumKLl/OqNxiXiJ7g2LjpRSW9wAAADQtWvDc8+fPC4UCaxJc2u4qwyrldrWLfE6l4XLe/HzzsVLcY4ypxcd0c1vVMq2UaVilYZWGH2c2LUH5nJXC5feQv1LWPuRz2re7yrCqrFgq6Z83t2UrXSuuS1CLjym368igFh8bOvACnfqI0k3UjKzkefvkdtnmtlLcU4uPlRWWz1n2kYt7eq7NbZmTY+YRsFK2SvnLMUzkLGXa36E5n2dzW7ZsznXTSplqyvfX30VekTNWyxXirhhTM7LtGgAAAGguGux9e9FYfbFIJ/LG4lbq2hmFXs6tml+3TQy2EVHij2/Qr7+vaWndMTYtZ94hold3syXp1o61TXzulLYyZ+X3kt/9tkKv1reezT0levqisPXPDTox0G3ptThbkkZKUva3mHNtSV+FSgyeZ9dOl/6xXzEzj5SSq6+IXpX/m4jeir/Dpf98iunbr17pJmvlCjlpPxl/Ukk+aZuwNHk2R2esJbr2s8U///5gq7a9XfjJUQaN9bz334xxZeRumU3LmVN2Sd3v9T/5qUBERIXF/X7ltC7/6au7Wb290uxLqx+95YehMLdYuatHDUjSlUWqlNesbxOdMds1AAAA0Fw02Pv2DgN9x9aNsYe7tRPL7j/YokS7OJ83pwfO/Xhn8QWdO5OnX+YWX1XOnUpxX3tuIJ57O+VMcu9yWhrqm6RPf5Ru/VP94mzCM92ftuwnZzrpdIKoYVyXtuy1NmfKX6lvlVLv79yhUxt6j7wVP3dy4trhHeM4H1cyEwvYqwUAANCatMTaXvfbCr28ck8/hVC49+OifY3NxbO+kVLfqn5R+sd+hd7o9HH1vOWff/eNytOX9O5b59+lxaev5HffiqB+4i9tMiefVjckTb2tndjIRoEodS3BphNs8IS+puWVbnE+Lotqaj+dcgQU0i/j1mLe/oOf37xoZXi1rn1lVOeNv5za2E5UdL8X/25n3FrYI6K2i+/uXwp9zCW4/omL8XnvU0Cl9Q05fj5k5QAAAEDDIDHGiOjFixcPHz68fPnycesTCJG23CkKY53MjPqnc2eY8k8u6v9fbo+8oHMvF/VTBfpRCdspgT/+pL8lxHkIg1ynKPb7x89nyfjQ7jxCYTvQwL18xH7QgT+l4ToIQjY9XW94cZ8LoUKfNDfAFlK8ZC2beam1wlavbTHSqsVsL28EhylEcozGKoOJhfd1aTbbCuQYVvrubee5E+sUiJHfS75mVYH+fnDHNIhIyWvG077BS1gAAAA0My3j7QE7pfHY7c4N02MBUYEhAQAANDstsZML3CSyN+hOPV9R+JpSuD3fr78kEgAAAGhOWuGUhjQCp4aIiE3bNhtTC/rPzcE+Gg77BMO0IgAAANCstIK3F+kp/hoB+wAAAACvM9jJBQAAAABoZeDtAQAAAAC0MvD2AAAAAABaGXh7AAAAAACtDLy96FSnuiQRXVNVouUhSRpaPm4VdRpFmeUh3URHp0x1quvg1dVFCDgyGri/mvUWAAA0OfD2DkR6iTHGWGUyScnJCmOMsaU00eKQ1Dtz3LoZLDeIMstD0kRnRbPQzMRU9WiqlMfURhACjowG7q9mvQUAAM0PvL2DMDjQ40rruT5I8fuVyeQx6COkpzGUWZ6boQvxDiLquc/Yo9GOI6iz5z47eNvrIgQcGfXpr+pUV93Xw5r2Fnh9OYxhAMDxAG8vOh2jo25nzzP5Nada/v64VWhg9sdvlaSRtfEtI2FrJzZSkm7tRH4vdml2LTa7H12j1Q1ppGT7O4AyTUh1ve4LYrgFmo9DGAYAHBPw9g4VI7TP+vfQCvbrcuzkGBE9Q8v2z7YAQVOQS44enaOVFP476lTGFncoSHQJ0asws/At8NdH0raTZnrN77l6TDGOJiwPSVLXVJVXO6g9zegor20sYdsdeAhxa26mDC1bhczoTe2jFjrp1l+jLfvFGeUdml98pl2X/vE7vXMi/8VZ//diF+5tFDy+Sgye3xhs8y3tS3eMDZ6Qu2U2nWDTCTZ9RokuyxMf/TVE3eRpyVqd7lXQ3aF68MNMr6urXp9bIGTVWt2u2UNPGFr21FOskZdBXM1zzpZ+HeSoRZPGS3Zo6D0MAGhGGGOMsefPnxcKBdYkNJy2fNyelUKkJS6l9Q+sMpk0slUmk2bYn70UFwtI6SVHocklJpKTThv96RTpqYwz1tBIdNZlsGRWoedYSpvVBdDH1l6+7spkkig5WVmyF7G2n0y1g9rT+t4oJ7Kzq+12PISINDc+860za1xKp5cs2zn059lVcrv5XDnv/MwYY/mcSsPan5m4qwybiSoNq8qKkXulrKXIxT1HHQI5K2UaVpXituyUz9hKWS7uMbaXyW2rRppafGwJ3zRK3dQycCrdNIp4yvfW30TQTZ6WrNXpXgU9OlR4e74+t0DQqr1MZ0mrTCaNxvhOfUEMIihhny3TPh3kLMndod6WFKsKQFMCb68eeHh7zjMc1uRln5M8S1kzjm3KEcrxmZiEyjiFmS6g9/TmqMK8DKIPf7mUttXhNbcKrVHTno4G+s7XtrY7WyoS4qW5rYS9qdbXnl3AGNM8PLa5rRT31OJjZYWZ3l4+x/ltm9vyTcv34j1CJ7qvZuEpZ6XMO39WHsNrJK5GZ57NbTm3a8h/nNm08lBN+f76c7iHqNOSQTrdcwgFGIpCIazlb4GaVYvvBe6bymR6ssICTH1hO8JLQx8DOqozHcKkt4bw9kALgZ3co0Fd1zYU7JNcoEDtjtFHlcnkTK9tKyOCHJcy2r7F3AA30wnr8lQsfoHo+3I1rD7O+CVeTsgmuOutLs6qeii8H4K28996CPHRvEMZTKqzi1Wi5S/Xby+lZyamqlSdmuu8LgziNPR30H4y/qSSfNI20W0mPZujM9aebPvZ4p9/f7AlKlsDPznKYCylfXr/zRhXRu6W2bScOWWX1P1e/5OfCkREVFjc71dO6/KfvrqbNYL8Zl/Sr7+vGSW85NfEv5uISLNkwE4XFDzgUGzdW6Bm1T5N6Bkwjhwvf7k+YBjC1z71MIgILzk91ydp7MtlouU5uh1IQwCaHXh7R4vHU74GHaOPmPbahl7dB4smh2d5SB67sMTYfYc34q7LF/2pEkafjvgFopk5u/Cwz2odV72BHhNeba8lxE/zjtHbaXXsy+XlORro6RlIq2NfTi2udyrhmtWW/eRM/pMa4XpHS1v2mkOftuxfaW6VaGvnDp3KtmuJb8XPnVT1ID/tz/DwIlOrm0wi+wZ1GYoteQvUxK8JPdcnk+rYl1O2f3Z87VNPg7gQyelQBpMzE0NDEzQQTEMAmh14e0dIz/XJ5EyvGTe8POQMIebm6erirB5bXZ2a0ibBnvtLafq+XK0tJwDV8vfmI8H6x9pdlwtzSl4e6p1JTl7vCdAuBz3XJ5OWM1mdmtDlhEVYb89AmtQx2c9TFbfdJtlDiK/mPQNpmumd6Lzeo38esxY2gtN+OtXOX58eoF+ss7q0/+DnNy9aGV6ta19t7cRG/E88+Mupje1ERfd78e92xq2FPSJqu/ju/qXQp4D99K/dTSYBOt2jYJSh+FrcAoGq9mpCx+ht+/ivaZ8IBhHOlkQk7CB36dHbaXVm5oLh7NVjUgWgodFWrRsuEs6XhtKWf5uVPTCaiJKTS/Z4Z37XRBQPYpVMp5NaJr4Cq4hDjk88s5cyXMy5XhelJ4V12ZqaTNobFEQffquID7SxyXE0gbvktOI++9hTsDXlEbPPtd3Tbg4hbs35Ilzwt+2zUcA5HjTMIwta6Jt5aRza8DrNsOk+/bCXuWk7/eB1MEKXYwTnKSuWNLm4ZwXtCeQYBY2IPRPuFIiR30u+p/41uok8Lenf6T5dIOxQM9E+Ll6XWyBg1T73gnE8w9M+bmoaxHN8OGZLjw5y15e2f+3WkB8G/KksAJoPiTFGRC9evHj48OHly5ddU0Qj0lzatg7VqS557MJS9N0fAJob3AINTogOWh7qKl9HdB54bfjDcSsAAAAAHCnVqQm6/QiuHnh9gLcHglGd6pLHVCK1VyKsbdQbaeR1+qEKb9h0Ix1Q+f/bu3+YNpI9DuC/lZ5yT3pYVyTRcUEnRUKsAV2UwuZqN68BLTnRRKQJOSNoI5CJQgqU4nQ6IyAtUpBd2UqDCJZproA6WUt3JOKMDQLpKQenJFLAFC8084r9N7s7u941EMDv+1EKPJ79zezMYk9mZxYH/ApccME6SM+VLLKxL1s9gHOFO7kAAAAAzQx7cgEAAACaGUZ7AAAAAM0Moz0AAACAZmat2zvvmgAAAADA6bP25C4tLZ1jPUL58ccfL1FtAQAAAM6R7Qksl2WXqzYTeVlqCwAAAHCOsG4PAAAAoJlhtAcAAADQzDDaAwAAAGhmGO0BAAAANDOM9gAAAACaWbjRXrZfkvqzDRST7ZckSYpO4E+/AwAAAHxR4UZ7Q8sZpaFihpYZU1PRho4FAAAAgIY1cCd3YyIq8TN1Jf21Ne3nTnHTZvv4PGaKFrg0EZWkaNReFgAAAACEEn60V5guP2aMMfa4fG+iRKWJe/prpnb+0p8lQYpbtv9BwQz4QMsztKwdlImW3xBRLJ1LyZXoYy4JAAAAAEL6R/0sDnJqaug0SlYybJkPlO2XjBGgkjEzDZxKWQK1iSeV6Q9EdCU1GHn5G+V+vhnT39rvH323mZA3ByMNRy/l38TXjomIutrYw9Y6udc2pfyRI00ZjC0nQpVpnhFRV1uG3j34k4iIrl1VrVPzk+2PbkxtpmNanCupiVvpdiIi2t6Npj9WAsdxK+Xf3KObjbenu31OUJkzZrTiedcDAADAos2nffr0KZvNsnpsq/bklKpN4KVkPUXJMHGK7TgtzcqjBTJfK4pCJKdUPUHJ6EcbxQWvrd+JzKk0uaMyxthhatL8+ZRl5lSa26ufb7VMI+WMlX9PGVGV1QYKtB9ohA1ETclG9zG2p0yuy0bN1VxZnqwfJzMXuKwGrJbl3KHxYk85g/46rfrbGhIAAOACCDe3N7TMhlyJsfQmS/unCI5z5XFFITNhSFCqEzezZUz86BNsXW3qN+/ja8dE5nxVbeM90fV/xoiIIumfY2bBwjk57zjGvBcR0ZVU4sr02pHtXYH9/tF3xk3slsx81P/Mss9K+hSdeV5Gicqg3Pmbdsq+cYLlzz6djg4w6/X164/pIEutQ7T/9O+vH18/EFXJjGOc1GjpARHxE5PGtJzsmisVxFnblPJHSuLq5prWpO561iaefbz78Obyz0RcZ8kJefOHj3pH6L3PtbM5EegZ37v+nripaDmlcpN5sfRjik6UhjC9BwAAF4Y26Dv5bNmX5KrtnjJizaJl5lRzTiszp9LkupI7ZIypuXVrDm+1TCMqjag0sp7acsZ3z8mJ42ztyCOqMee0p4yojrk0Z5ytHZmbe1Nz647SfecCD1OTtrLkybJ2LBfHa27PK7/JMSG1p8ztsa0dJXeo5taVVWveKzOnWnNsWzsyN8fmNzdmm5nzjcPPR/JHmf3lmNXj82ztyNY1wJ3gapnqxg85t5dRuKnmjMJPPDOmpmTbawAAgPPVFE9XXjsoUEvGmIobetim0NHimvl2ZGowQkSxb6/Qh8/6bo9ElM3LqWtEdDydLklPdgPs+XXGKb2qVa5dzelTVq3Lgy3+x5de1SpEhXxJGi1Jo6X42jHRcfk//qe2qWWWRo2ZS9P3N7QZxNjgzdS145evanWq75f/Tbniyt9+tfNtJf42MpUwk/YXqc2aomu/mfv+84vtOsWK+MVRBo35vO++4h/ZIydkNi+nrtsjJW7ceftXloiIsoXaHaVVj//n8XRab2cpf2T1u3f8MLKLhcp03NhU/qBAFX4XUaw7WsGuIgAAuDjC79K4dPQ7tm7GPdzt3Wi69mKbYp63X/3jhFL/7q1lezeaPzLuKtYmnlRecm9Gvw236SFsfqJI+qe2bmqNEV2YoUsk/TDiTPk39a/R0He7v9D1Tb0H/9XZdXXq4dlt47jVqaSmlnGvFgAALoemmNtLfK3Q0YNn+9qr7LN3BWoZSPgcsN8/Wupf01+UXtUqdKXbf6gnEvshIn/4eC9f02O69tUK8nP11ObtzGoI/OdzxTyRtb8cc3uF/GaWzLeu3PkhQtQ60EWF37R5ytrEb0fU9fWQX37TrU6ZBNpbh2zN0jpA7yesybzai7+/umtlON7Q3trejY4aZYn5x6kv+4yLn7jR+fvuhDWxR0SRu9/UjH4JLnj9Y3c7X97zfARkaWNT7rwVsnAAAIAzIzHGiOjg4GBpaen+/fvnXZ9ARLXldmkY82e2LRfKf7lV/P98OnpAXUcFfZcAv6+C30Whp3vHsfZMELVkBulBnjLz0SFbEEcR9rf4J4mINjRYWxm6rqbef5z+oG0fof7RdzTYRnktlG1fCHeIudFk3ye/flS/tDigPRLHrKGWzXzZ4j41224Gvin0+Uu+U2xdQ8I4Rgsog7Hl7/RockLe/PYv1xNq7FOka5vS7187nnRj2+Ci5feKr7W2oP5+uG0aZH+eEB7CAgAAF0vTjPbOX/ZZ6cH7L/McOG30FvyBfAHylyaiT7s3bU9AhEagIQEA4KL5P1i3d6asCSEiasnMn/1QzywxX5LyAWahAubHg0NOR/bpyztT6fr5AAAAvphmmNuTRvFHdBvB5sUjO7Snxqt9AAAALpdmmNvDt/LpQnsCAAA0k6bYkwsAAAAAHjDaAwAAAGhmGO0BAAAANDOM9gAAAACaGUZ7DVsZNv5QqjS8Ik7vma0GDmXG4I63B/ZRne0JntmjXDglwlYN1dTolwvlTLvj/Ppa/KGBaw+gOWG017De54wxVpmJEy30cZ+Pvc8Zq8zEk0XGXo91hAy6MixNdVcYY8VkmGPkcTVkQUQrw1LfQuijoAGhmhr9cqE0aXc0+KEBAJcVRnsndjuZjNNCX9B5PEN1tsf8P3Tvc8ae9xLRyuIC3e7sIGMs+bw3QKTe59qYM6Te540c1TD+fJub2ZvmKQdp6lCZ4aw11h1eF7nPxW9eLV+W54eG++oFgGaA0d7JdT96XUySOi6H+mysbrj/Z10t/3F61bpgROfb5EKd8nm1T23iSUkafTOxbSRs70ZHS9KT3YYfsV3Kv4nma43XaG1TGi3Z/p2gMo1qrDu8jrqMF/9lrDMAeMJo71SmP02tAAAGzElEQVRoEwC2G7qc6myPYyWffntooU9bm7cyLEk9PT3avZWFPi0fv4DGisBPIVor/AQ3ZcxD9PjW0dorK5CR06q8uzitMu6cwpN0Z3CcryizvorIfMdrrtTdmK500YnwzTC8Qraf9aK1JEf1HGcSpFW1tnKeskdTi9sncL9wAfxOzadVI+mf25Rr9LKwr70uvfpM11oy9f7cc/bZZtbjrdjgrc3BiO/RvhJRNtgiJ2Q2H2PzMTbfpjQey5NP/QN2h+saFh7liua82Lhfc37FrlmSMNF9Jbiu4YY+NIj8rl4AuMwYY4yxT58+ZbNZdklcpNpWZpIzFf2nOBHFZyrMXLdnJMf5LGYOomSRmSv0kkWPRFaZidsCaJGLSTLjarmNErm6xYmvhpmhmDQCk1FlK5y7OHMNoSOnoyi+NsIMRgXcmWfMVYp6ejEpOiGvxuTPznYirkRnNSiZNIvmmsoqY0ZYB+9WFfamV1P7tE+QfqkTgTs1/1bdU+b2MnPljPNnxhjLzKk0ov0zE/eUETNRpRFVWTVyr5a1FDl36ChDEGe1TCOqktuRnfEZWy3LuUPGDlNzO6qRpubWreBbxlGTWgauSpPGIZ7xvesfvDuEF7ywX/hoRcfFxv+aF5NGKhdbmOi6EtzXcIMfGh5XLwBcfhjtnZA12mPcB6g12rM+rvXscY+hgGeia79GfKZi+7Jhnh/N9m8IssY+1heIawTmWZxorOZiHO07mhFmdmQQnpFXYxaTghoJE+s2u5Hu80UXtFWFZTGPBqybWdgvDZ2a68z2lLk9trWj5A7V3LqyyszRXmaOG7dt7ciT1tiLHxE66WM1i2ec1TI/+LPyGKNG4kp05tnakef2jPjrqS0rD9WN719/FqLv/K7hutGYo6f48Zn5/zFXYt3fUL889T40vK4cALjkcCf3NJk3dAtGinMlXkfnbaI/yuE2dDi+2F+PdVQLeVXfzuGnQxmMq/lClWjl142nxeTC1GyVqrOL3Y+Ey8LVjaq4OM+cHO2+0eJAoO3E9TOLGsqrMYXLHRtfA9kx9royE1/oE91yJQrdqkKCBqyfuX6/1ONz+bVf7Xxbib+NTCXMpP1FarPuybbfzH3/+cW24NB6/OIog9Eh7afvvopyx8gJmc3Lqev2SIkbd97+lSUiomyhdkdp1eP/eTydNhb55Y/ow+c3xhFe8U9A745QF3x91lVFVN1Q490dXokU7Epo9EMDAJoSRnunq2MsNxOnhXFjSUxH522ihUX7mCH0J65rbBB00Ngx9jSpjv+6srJIA729A0l1/NfZwka34l9+qKGIZmVYHr9dDLi7MHBmR0N5NWZH521xEzVwIvrBY68ZY8WkeClmY616cg2fjp3H5RdJ/9SW+anOcr0vK5J+6KhPJP1vWlwj2t79ha6n27XEf3V2XVX1RX7aP2OEd3ZCXfCBaFeVLEmS1EdFfQQnTAx2JTT8oQEAzQijvROqbjimkDrGXvP/1+99xG/fqM5OLcRnQswB6RG4B7ysDPfMVql3IOAu4N6BJC30TXU/6tV/Ht8Y8J0UEhZXT7X8h/lFUndSzSezOZRbGe4TNJRXY2onya2nH9abyJXIfeNVC3mPDZSzs9pBvc+LSfHXY+hWPbm6/eJ9anVa1dTeOtTOv24doPfWXl2qvfj7q7tWhuMN7a3t3eioz46HunHqs+2oSNzo/H13wprYI6LI3W9q90LvAg5ef4FQF3wwK8N9ZNw4NceQosQgv6En+9AAgCakfZBcpJVw9V2Q2vLPq3IscOF2adgzWrdXfJ/iZa271g7gxo8+a3PE62yKSX4jge1no4iiWRdhcT45+VKMN5LJuKAy5vlaWxlsmWdm4kTxuEd4YasLF1DZ0gWJ1skYRTtbz6dfQ7Vqxd3FPg0YJLPwMhA0gXFqyWKlbquaWxa0pW/mS2PThtduhi337ofD1KRt94PXxgg9jrE4T1m1osm5Q2vRniCOcaCxYs/E7QIx8nvF96x/qO4QXvD8Re4fzbEEzxaQ6ythovtKcO7+EOVxJfodwl+92jpkn19JALgEJMYYER0cHCwtLd2/f9/1UXARXa7aQiDV2R55/HbxPJ4028TQqpdGdXa2OjbWa77qkTeeskdlQSI6EwBCw51cAIBzVp29N563Fg1UC3maedQhSsRQDwAa8I/zrgCAPgWlEql9EmEi6rQEa1Vp9Iv/oYoLic2f5waVjrHcTF6WpXHtZXym8nqsg0iYCAAQGu7kAgAAADQz3MkFAAAAaGYY7QEAAAA0M4z2AAAAAJqZtW7vvGsCAAAAAKdP35O7tLR0vvUAAAAAgLPwP1LbJcyJAKyRAAAAAElFTkSuQmCC" alt="" width="812" height="300" />
对这些方法做一下解释:
  • 按下(onDown): 刚刚手指接触到触摸屏的那一刹那,就是触的那一下。

  • 抛掷(onFling): 手指在触摸屏上迅速移动,并松开的动作。

  • 长按(onLongPress): 手指按在持续一段时间,并且没有松开。

  • 滚动(onScroll): 手指在触摸屏上滑动。

  • 按住(onShowPress): 手指按在触摸屏上,它的时间范围在按下起效,在长按之前。

  • 抬起(onSingleTapUp):手指离开触摸屏的那一刹那。

除了这些定义之外,鄙人也总结了一点算是经验的经验吧,在这里和大家分享一下。

  • 任何手势动作都会先执行一次按下(onDown)动作。

  • 长按(onLongPress)动作前一定会执行一次按住(onShowPress)动作。

  • 按住(onShowPress)动作和按下(onDown)动作之后都会执行一次抬起(onSingleTapUp)动作。

  • 长按(onLongPress)、滚动(onScroll)和抛掷(onFling)动作之后都不会执行抬起(onSingleTapUp)动作。

二.手势事件:滑动动速度跟踪类VelocityTracker介绍

VelocityTracker顾名思义即速度跟踪,在android中主要应用于touchEvent, VelocityTracker通过跟踪一连串事件实时计算出当前的速度,这样的用法在android系统空间中随处可见,比如Gestures中的 Fling, Scrolling等。

android.view.VelocityTracker主要用跟踪触摸屏事件 (flinging事件和其他gestures手势事件)的速率。用addMovement(MotionEvent)函数将Motion event加入到VelocityTracker类实例中.你可以使用getXVelocity() 或getXVelocity()获得横向和竖向的速率到速率时,但是使用它们之前请先调用computeCurrentVelocity(int)来初始 化速率的单位 。

主要函数
 
Public Methods
void addMovement(MotionEventevent)

Add a user's movement to the tracker.
void clear()

Reset the velocity tracker back to its initial state.
void computeCurrentVelocity(int units, float maxVelocity)

Compute the current velocity based on the points that have been collected.
intunitis表示速率的基本时间单位。unitis值为1的表示是,一毫秒时间单位内运动了多少个像素, unitis值为1000表示一秒(1000毫秒)时间单位内运动了多少个像素
floatVelocity表示速率的最大值
void computeCurrentVelocity(int units)

Equivalent to invoking computeCurrentVelocity(int, float)with a maximum velocity of Float.MAX_VALUE.
abstract T getNextPoolable()
float getXVelocity()

Retrieve the last computed X velocity.
float getXVelocity(int id)

Retrieve the last computed X velocity.
float getYVelocity(int id)

Retrieve the last computed Y velocity.
float getYVelocity()

Retrieve the last computed Y velocity.
abstract boolean isPooled()
static VelocityTracker obtain()

Retrieve a new VelocityTracker object to watch the velocity of a motion.
void recycle()

Return a VelocityTracker object back to be re-used by others.
abstract void setNextPoolable(T element)
abstract void setPooled(boolean isPooled)
 
示例:
 
 private VelocityTracker mVelocityTracker;//生命变量
//在onTouchEvent(MotionEvent ev)中
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();//获得VelocityTracker类实例
}
mVelocityTracker.addMovement(ev);//将事件加入到VelocityTracker类实例中
//判断当ev事件是MotionEvent.ACTION_UP时:计算速率
final VelocityTracker velocityTracker = mVelocityTracker;
// 1000 provides pixels per second
velocityTracker.computeCurrentVelocity(1, (float)0.01);//设置maxVelocity值为0.1时,速率大于0.01时,显示的速率都是0.01,速率小于0.01时,显示正常
Log.i("test","velocityTraker"+velocityTracker.getXVelocity());
velocityTracker.computeCurrentVelocity(1000); //设置units的值为1000,意思为一秒时间内运动了多少个像素
Log.i("test","velocityTraker"+velocityTracker.getXVelocity());
大体的使用是这样的:
 
当你需要跟踪触摸屏事件的速度的时候,使用obtain()方法来获得VelocityTracker类的一个实例对象
 
在onTouchEvent回调函数中,使用addMovement(MotionEvent)函数将当前的移动事件传递给VelocityTracker对象
 
使用computeCurrentVelocity (int units)函数来计算当前的速度,使用getXVelocity ()、 getYVelocity ()函数来获得当前的速度
下面是我写的一个简单Demo:

 package com.bxwu.demo.component.activity;
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.ViewConfiguration;
import android.view.ViewGroup.LayoutParams;
import android.widget.TextView; public class VelocityTrackerTest extends Activity {
private TextView mInfo; private VelocityTracker mVelocityTracker;
private int mMaxVelocity; private int mPointerId; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); mInfo = new TextView(this);
mInfo.setLines(4);
mInfo.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
mInfo.setTextColor(Color.WHITE); setContentView(mInfo); mMaxVelocity = ViewConfiguration.get(this).getMaximumFlingVelocity();
} @Override
public boolean onTouchEvent(MotionEvent event) {
final int action = event.getAction();
acquireVelocityTracker(event);
final VelocityTracker verTracker = mVelocityTracker;
switch (action) {
case MotionEvent.ACTION_DOWN:
//求第一个触点的id, 此时可能有多个触点,但至少一个
mPointerId = event.getPointerId(0);
break; case MotionEvent.ACTION_MOVE:
//求伪瞬时速度
verTracker.computeCurrentVelocity(1000, mMaxVelocity);
final float velocityX = verTracker.getXVelocity(mPointerId);
final float velocityY = verTracker.getYVelocity(mPointerId);
recodeInfo(velocityX, velocityY);
break; case MotionEvent.ACTION_UP:
releaseVelocityTracker();
break; case MotionEvent.ACTION_CANCEL:
releaseVelocityTracker();
break; default:
break;
}
return super.onTouchEvent(event);
} /**
*
* @param event 向VelocityTracker添加MotionEvent
*
* @see android.view.VelocityTracker#obtain()
* @see android.view.VelocityTracker#addMovement(MotionEvent)
*/
private void acquireVelocityTracker(final MotionEvent event) {
if(null == mVelocityTracker) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(event);
} /**
&nbsp; &nbsp; &nbsp;* 释放VelocityTracker
&nbsp; &nbsp; &nbsp;*
&nbsp; &nbsp; &nbsp;* @see android.view.VelocityTracker#clear()
&nbsp; &nbsp; &nbsp;* @see android.view.VelocityTracker#recycle()
&nbsp; &nbsp; &nbsp;*/
private void releaseVelocityTracker() {
if(null != mVelocityTracker) {
mVelocityTracker.clear();
mVelocityTracker.recycle();
mVelocityTracker = null;
}
} private static final String sFormatStr = "velocityX=%f\nvelocityY=%f"; /**
* 记录当前速度
*
* @param velocityX x轴速度
* @param velocityY y轴速度
*/
private void recodeInfo(final float velocityX, final float velocityY) {
final String info = String.format(sFormatStr, velocityX, velocityY);
mInfo.setText(info);
}
}
 

代码很简单,我们可以求出move过程中的伪瞬时速度, 这样在做很多控件的时候都是可以用到的,比如系统Launcher的分页,

ScrollView滑动等, 可根据此时的速度来计算ACTION_UP后的减速运动等。实现一些非常棒的效果。

android手势处理揭秘

【转】android 手势识别和VelocityTracker的更多相关文章

  1. Android手势识别的发展

    在播放器.与手势识别.所以,看看今天的我们Android手势识别. 首先,我们需要站在巨人的肩膀上.有些人举了个例子和说明. 第一章: http://www.2cto.com/kf/201110/10 ...

  2. 札记:android手势识别,MotionEvent

    摘要 本文是手势识别输入事件处理的完整学习记录.内容包括输入事件InputEvent响应方式,触摸事件MotionEvent的概念和使用,触摸事件的动作分类.多点触摸.根据案例和API分析了触摸手势T ...

  3. 代码讲解Android Scroller、VelocityTracker

    在编写自定义滑动控件时常常会用到Android触摸机制和Scroller及VelocityTracker.Android Touch系统简介(二):实例详解onInterceptTouchEvent与 ...

  4. Android手势识别(单击 双击 抬起 短按 长按 滚动 滑动)

    对于触摸屏,其原生的消息无非按下.抬起.移动这几种,我们只需要简单重载onTouch或者设置触摸侦听器setOnTouchListener即可进行处理.不过,为了提高我们的APP的用户体验,有时候我们 ...

  5. Android手势识别总结

    一:首先,在Android系统中,每一次手势交互都会依照以下顺序执行. 1. 接触接触屏一刹那,触发一个MotionEvent事件. 2. 该事件被OnTouchListener监听,在其onTouc ...

  6. android手势识别ViewFlipper触摸动画

    使用ViewFlipper来将您要来回拖动的View装在一起,然 后与GestureDetector手势识别类来联动,确定要显示哪个View,加上一点点动画效果即可.比如当手指向左快速滑动时跳转到上一 ...

  7. Android 手势识别—缩放

    上一篇讲解了手势识别中的点击和双击事件的识别,用到的是GestureDetector类和GestureDetectorCompat类,用于监听用户触摸屏幕中的简单动作. 缩放 基本用法如下,可以通过缩 ...

  8. Android 手势识别——单击/双击

    为什么需要手势识别? 手势对于我们的app有很多的地方都在使用,比如右滑关闭界面等.手势控制分为触发动作(Touch Mechanics,用户手指在屏幕上如何动作)和触发行为(Touch Activi ...

  9. 代码解说Android Scroller、VelocityTracker

    在编写自己定义滑动控件时经常会用到Android触摸机制和Scroller及VelocityTracker.Android Touch系统简单介绍(二):实例具体解释onInterceptTouchE ...

随机推荐

  1. AD芯片的基准参考电压问题

    基准参考电压的精度一般非常高的! AD芯片 : AD9226的基准参考电压  误差一般是  千分之一! 我之前用万用表测量AD9226的参考电压大概是1.89V(这款AD的正确参考电压应该是2V),所 ...

  2. 静态实现AOP(翻译自MSDN)

    在.net实现AOP 本文通过一个简单的例子实现静态AOP.改例子主要实现客户的增删改查,突然有一天你的老板需要在程序上跟踪每个方法操作的运行日志. 主要分为5个步骤. 第一步:创建接口IReposi ...

  3. pymysql简单链接示例

    #!/usr/bin/env python # encoding: utf-8  # Date: 2018/6/24 import pymysql username = input('username ...

  4. 赋予oracle执行存储过程权限和创建表权限

    grant create any table to username; grant create any procedure to username; grant execute any proced ...

  5. Oracle11gR2--删除数据库

    1. 停止ORACLE数据库 [oracle@localhost oracle]$ ps -ef|grep smon oracle 72550 1 0 14:23 ? 00:00:00 ora_smo ...

  6. 0k6410定时器详细分析

    看到一篇很好的博文,分析2410定时器中断的使用的,很详细,和大家分享一下 转载来源于http://www.cnblogs.com/Neddy/archive/2011/07/01/2095176.h ...

  7. CSS秘密花园:多边框

    今天在查询CSS3动画相关资料时偶然发现这个,感觉有时还是挺方便的.原文链接:http://www.w3cplus.com/css3/css-secrets/multiple-borders.html ...

  8. Python基本数据类型之字符串、数字、布尔

     一.数据类型种类 Python中基本数据类型主要有以下几类: Number(数字) String(字符串) Bool (布尔) List(列表) Tuple(元组) Sets(集合) Diction ...

  9. s=1+2*3+4*5*6+7*8*9*10+.... C语言求解

    #include <stdio.h> /*类似斐波那契数列的计算方式 项 1 2 3 4 1 2*3 4*5*6 7*8*9*10 生成项的起始数字 1 2 4 7 和后一项的差值 1 2 ...

  10. 201671010127 2016—2017-2 通过一个小程序对Java的再认识。

    学习了将近四周的Java语言,对于Java语言,我也有了更进一步的理解,出于对Java语言的喜爱,我总是喜欢没事的时候,自己敲一些很简单的代码,一边学习Java语言,一边对比C语言,往往可以帮助我们更 ...