Naoto Morita / MatrixMath

add MatrixCross

MatrixMath.cpp@7:b22d56ac37aa, 2021-08-10 (annotated)

Committer:
NaotoMorita
Date:
Tue Aug 10 08:08:11 2021 +0000
Revision:
7:b22d56ac37aa
Parent:
6:aa5e94cddb3f 
add Vector3;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Yo_Robot 3:48754fe86e08 1 /**
Yo_Robot 4:d360c068d55f 2 * @brief version 0.9
Yo_Robot 3:48754fe86e08 3 * @file MatrixMath.cpp
Yo_Robot 5:93948a9bbde2 4 * @author Ernesto Palacios
Yo_Robot 3:48754fe86e08 5 *
Yo_Robot 5:93948a9bbde2 6 * Created on 15 de septiembre de 2011, 09:44 AM.
Yo_Robot 5:93948a9bbde2 7 *
Yo_Robot 5:93948a9bbde2 8 * Develop Under GPL v3.0 License
Yo_Robot 3:48754fe86e08 9 * http://www.gnu.org/licenses/gpl-3.0.html
Yo_Robot 3:48754fe86e08 10 */
Yo_Robot 3:48754fe86e08 11
Yo_Robot 3:48754fe86e08 12 #include "mbed.h"
Yo_Robot 3:48754fe86e08 13 #include "MatrixMath.h"
Yo_Robot 3:48754fe86e08 14
Yo_Robot 3:48754fe86e08 15 ///Transpose matrix
mori3rti 6:aa5e94cddb3f 16 Matrix MatrixMath::Transpose(const Matrix &Mat)
Yo_Robot 3:48754fe86e08 17 {
mori3rti 6:aa5e94cddb3f 18 Matrix result(Mat._nCols, Mat._nRows); //Transpose Matrix
Yo_Robot 3:48754fe86e08 19
mori3rti 6:aa5e94cddb3f 20 for (int i = 0; i < result._nRows; i++)
mori3rti 6:aa5e94cddb3f 21 for (int j = 0; j < result._nCols; j++)
Yo_Robot 3:48754fe86e08 22 result._matrix[i][j] = Mat._matrix[j][i];
Yo_Robot 3:48754fe86e08 23
Yo_Robot 3:48754fe86e08 24 return result;
Yo_Robot 3:48754fe86e08 25 }
Yo_Robot 3:48754fe86e08 26
NaotoMorita 7:b22d56ac37aa 27 ///Transpose matrix
NaotoMorita 7:b22d56ac37aa 28 Matrix MatrixMath::Matrixcross(const float px, const float py, const float pz)
NaotoMorita 7:b22d56ac37aa 29 {
NaotoMorita 7:b22d56ac37aa 30 Matrix result(3,3); //Transpose Matrix
NaotoMorita 7:b22d56ac37aa 31 result(1,2) = -pz;
NaotoMorita 7:b22d56ac37aa 32 result(1,3) = py;
NaotoMorita 7:b22d56ac37aa 33 result(2,1) = pz;
NaotoMorita 7:b22d56ac37aa 34 result(2,3) = -px;
NaotoMorita 7:b22d56ac37aa 35 result(3,1) = -py;
NaotoMorita 7:b22d56ac37aa 36 result(3,2) = px;
NaotoMorita 7:b22d56ac37aa 37 return result;
NaotoMorita 7:b22d56ac37aa 38 }
NaotoMorita 7:b22d56ac37aa 39 Matrix MatrixMath::Vector2mat(const Vector3 vec)
NaotoMorita 7:b22d56ac37aa 40 {
NaotoMorita 7:b22d56ac37aa 41 Matrix result(3,1); //Transpose Matrix
NaotoMorita 7:b22d56ac37aa 42 result(1,1) = vec.x;
NaotoMorita 7:b22d56ac37aa 43 result(2,1) = vec.y;
NaotoMorita 7:b22d56ac37aa 44 result(3,1) = vec.z;
NaotoMorita 7:b22d56ac37aa 45 return result;
NaotoMorita 7:b22d56ac37aa 46 }
mori3rti 6:aa5e94cddb3f 47 Matrix MatrixMath::Inv(const Matrix &Mat)
Yo_Robot 3:48754fe86e08 48 {
mori3rti 6:aa5e94cddb3f 49 if (Mat._nRows == Mat._nCols)
Yo_Robot 3:48754fe86e08 50 {
mori3rti 6:aa5e94cddb3f 51 if (Mat._nRows == 2) // 2x2 Matrices
Yo_Robot 3:48754fe86e08 52 {
mori3rti 6:aa5e94cddb3f 53 float det = MatrixMath::det(Mat);
mori3rti 6:aa5e94cddb3f 54 if (det != 0)
Yo_Robot 3:48754fe86e08 55 {
mori3rti 6:aa5e94cddb3f 56 Matrix Inv(2, 2);
mori3rti 6:aa5e94cddb3f 57 Inv._matrix[0][0] = Mat._matrix[1][1];
Yo_Robot 3:48754fe86e08 58 Inv._matrix[1][0] = -Mat._matrix[1][0];
Yo_Robot 3:48754fe86e08 59 Inv._matrix[0][1] = -Mat._matrix[0][1];
mori3rti 6:aa5e94cddb3f 60 Inv._matrix[1][1] = Mat._matrix[0][0];
Yo_Robot 3:48754fe86e08 61
mori3rti 6:aa5e94cddb3f 62 Inv *= 1 / det;
Yo_Robot 3:48754fe86e08 63
Yo_Robot 3:48754fe86e08 64 return Inv;
mori3rti 6:aa5e94cddb3f 65 }
mori3rti 6:aa5e94cddb3f 66 else
mori3rti 6:aa5e94cddb3f 67 {
mori3rti 6:aa5e94cddb3f 68 printf("\n\nWANRING: same matrix returned");
mori3rti 6:aa5e94cddb3f 69 printf("\nSingular Matrix, cannot perform Invert @matrix\n ");
Yo_Robot 5:93948a9bbde2 70 Mat.print();
mori3rti 6:aa5e94cddb3f 71 printf("\n _____________\n");
Yo_Robot 3:48754fe86e08 72
Yo_Robot 3:48754fe86e08 73 return Mat;
Yo_Robot 3:48754fe86e08 74 }
mori3rti 6:aa5e94cddb3f 75 }
mori3rti 6:aa5e94cddb3f 76 else
mori3rti 6:aa5e94cddb3f 77 { // nxn Matrices
Yo_Robot 3:48754fe86e08 78
mori3rti 6:aa5e94cddb3f 79 float det = MatrixMath::det(Mat);
mori3rti 6:aa5e94cddb3f 80 if (det != 0)
Yo_Robot 3:48754fe86e08 81 {
mori3rti 6:aa5e94cddb3f 82 Matrix Inv(Mat); //
Yo_Robot 3:48754fe86e08 83 Matrix SubMat;
Yo_Robot 3:48754fe86e08 84
Yo_Robot 3:48754fe86e08 85 // Matrix of Co-factors
mori3rti 6:aa5e94cddb3f 86 for (int i = 0; i < Mat._nRows; i++)
mori3rti 6:aa5e94cddb3f 87 for (int j = 0; j < Mat._nCols; j++)
Yo_Robot 3:48754fe86e08 88 {
mori3rti 6:aa5e94cddb3f 89 SubMat = Mat;
Yo_Robot 3:48754fe86e08 90
mori3rti 6:aa5e94cddb3f 91 Matrix::DeleteRow(SubMat, i + 1);
mori3rti 6:aa5e94cddb3f 92 Matrix::DeleteCol(SubMat, j + 1);
Yo_Robot 3:48754fe86e08 93
mori3rti 6:aa5e94cddb3f 94 if ((i + j) % 2 == 0)
mori3rti 6:aa5e94cddb3f 95 Inv._matrix[i][j] = MatrixMath::det(SubMat);
Yo_Robot 3:48754fe86e08 96 else
mori3rti 6:aa5e94cddb3f 97 Inv._matrix[i][j] = -MatrixMath::det(SubMat);
Yo_Robot 3:48754fe86e08 98 }
Yo_Robot 3:48754fe86e08 99
Yo_Robot 3:48754fe86e08 100 // Adjugate Matrix
mori3rti 6:aa5e94cddb3f 101 Inv = MatrixMath::Transpose(Inv);
Yo_Robot 3:48754fe86e08 102
Yo_Robot 3:48754fe86e08 103 // Inverse Matrix
mori3rti 6:aa5e94cddb3f 104 Inv = 1 / det * Inv;
Yo_Robot 3:48754fe86e08 105
Yo_Robot 3:48754fe86e08 106 return Inv;
mori3rti 6:aa5e94cddb3f 107 }
mori3rti 6:aa5e94cddb3f 108 else
mori3rti 6:aa5e94cddb3f 109 {
mori3rti 6:aa5e94cddb3f 110 printf("\n\nWANRING: same matrix returned");
mori3rti 6:aa5e94cddb3f 111 printf("\nSingular Matrix, cannot perform Invert @matrix\n");
Yo_Robot 5:93948a9bbde2 112 Mat.print();
mori3rti 6:aa5e94cddb3f 113 printf("\n _____________\n");
Yo_Robot 3:48754fe86e08 114
Yo_Robot 3:48754fe86e08 115 return Mat;
Yo_Robot 3:48754fe86e08 116 }
Yo_Robot 3:48754fe86e08 117 }
mori3rti 6:aa5e94cddb3f 118 }
mori3rti 6:aa5e94cddb3f 119 else
mori3rti 6:aa5e94cddb3f 120 {
mori3rti 6:aa5e94cddb3f 121 printf("\n\nERROR:\nMust be square Matrix @ MatrixMath::Determinant\n");
Yo_Robot 3:48754fe86e08 122 }
Yo_Robot 3:48754fe86e08 123 }
Yo_Robot 3:48754fe86e08 124
mori3rti 6:aa5e94cddb3f 125 Matrix MatrixMath::Eye(int Rows)
Yo_Robot 3:48754fe86e08 126 {
mori3rti 6:aa5e94cddb3f 127 Matrix Identity(Rows, Rows); //Square Matrix
Yo_Robot 3:48754fe86e08 128
mori3rti 6:aa5e94cddb3f 129 for (int i = 0; i < Rows; i++)
Yo_Robot 3:48754fe86e08 130 Identity._matrix[i][i] = 1;
Yo_Robot 3:48754fe86e08 131
Yo_Robot 3:48754fe86e08 132 return Identity;
Yo_Robot 3:48754fe86e08 133 }
Yo_Robot 3:48754fe86e08 134
Yo_Robot 5:93948a9bbde2 135 // Very Versitle Function. Accepts two Vector Matrices of any type:
mori3rti 6:aa5e94cddb3f 136 // Vector types may be: [n,1] dot [n,1]
Yo_Robot 5:93948a9bbde2 137 // [n,1] dot [1,n] always same
Yo_Robot 5:93948a9bbde2 138 // [1,n] dot [n,1] 'depth'
Yo_Robot 5:93948a9bbde2 139 // [1,n] dot [1,n]
mori3rti 6:aa5e94cddb3f 140 float MatrixMath::dot(const Matrix &leftM, const Matrix &rightM)
Yo_Robot 3:48754fe86e08 141 {
mori3rti 6:aa5e94cddb3f 142 if (leftM.isVector() && rightM.isVector())
Yo_Robot 3:48754fe86e08 143 {
mori3rti 6:aa5e94cddb3f 144 if (leftM._nRows == 1)
Yo_Robot 3:48754fe86e08 145 {
mori3rti 6:aa5e94cddb3f 146 if (rightM._nRows == 1)
Yo_Robot 3:48754fe86e08 147 {
mori3rti 6:aa5e94cddb3f 148 if (leftM._nCols == rightM._nCols)
Yo_Robot 3:48754fe86e08 149 {
Yo_Robot 3:48754fe86e08 150 // Calculate ( 1,n )( 1,n )
Yo_Robot 3:48754fe86e08 151 float dotP;
Yo_Robot 3:48754fe86e08 152 Matrix Cross;
Yo_Robot 3:48754fe86e08 153
mori3rti 6:aa5e94cddb3f 154 Cross = leftM * MatrixMath::Transpose(rightM);
Yo_Robot 3:48754fe86e08 155 dotP = Cross.sum();
Yo_Robot 3:48754fe86e08 156
Yo_Robot 3:48754fe86e08 157 return dotP;
mori3rti 6:aa5e94cddb3f 158 }
mori3rti 6:aa5e94cddb3f 159 else
mori3rti 6:aa5e94cddb3f 160 {
mori3rti 6:aa5e94cddb3f 161 printf("\n\nERROR:\n Matrices have diferent depths @ MatrixMath::dot()\n");
Yo_Robot 3:48754fe86e08 162 }
mori3rti 6:aa5e94cddb3f 163 }
mori3rti 6:aa5e94cddb3f 164 else
mori3rti 6:aa5e94cddb3f 165 {
mori3rti 6:aa5e94cddb3f 166 if (leftM._nCols == rightM._nRows)
Yo_Robot 3:48754fe86e08 167 {
Yo_Robot 3:48754fe86e08 168 // Calculate (1, n)( n, 1 )
Yo_Robot 3:48754fe86e08 169 float dotP;
Yo_Robot 3:48754fe86e08 170 Matrix Cross;
Yo_Robot 3:48754fe86e08 171
Yo_Robot 3:48754fe86e08 172 Cross = leftM * rightM;
Yo_Robot 3:48754fe86e08 173 dotP = Cross.sum();
Yo_Robot 3:48754fe86e08 174
Yo_Robot 3:48754fe86e08 175 return dotP;
mori3rti 6:aa5e94cddb3f 176 }
mori3rti 6:aa5e94cddb3f 177 else
mori3rti 6:aa5e94cddb3f 178 {
mori3rti 6:aa5e94cddb3f 179 printf("\n\nERROR:\n Matrices have diferent depths @ MatrixMath::dot()\n");
Yo_Robot 3:48754fe86e08 180 }
Yo_Robot 3:48754fe86e08 181 }
mori3rti 6:aa5e94cddb3f 182 }
mori3rti 6:aa5e94cddb3f 183 else
mori3rti 6:aa5e94cddb3f 184 {
mori3rti 6:aa5e94cddb3f 185 if (rightM._nRows == 1)
Yo_Robot 3:48754fe86e08 186 {
mori3rti 6:aa5e94cddb3f 187 if (leftM._nRows == rightM._nCols)
Yo_Robot 3:48754fe86e08 188 {
Yo_Robot 3:48754fe86e08 189 // Calculate ( n,1 )( 1,n )
Yo_Robot 3:48754fe86e08 190 float dotP;
Yo_Robot 3:48754fe86e08 191 Matrix Cross;
Yo_Robot 3:48754fe86e08 192
mori3rti 6:aa5e94cddb3f 193 Cross = MatrixMath::Transpose(leftM) * MatrixMath::Transpose(rightM);
Yo_Robot 3:48754fe86e08 194 dotP = Cross.sum();
Yo_Robot 3:48754fe86e08 195
Yo_Robot 3:48754fe86e08 196 return dotP;
mori3rti 6:aa5e94cddb3f 197 }
mori3rti 6:aa5e94cddb3f 198 else
mori3rti 6:aa5e94cddb3f 199 {
mori3rti 6:aa5e94cddb3f 200 printf("\n\nERROR:\n Matrices have diferent depths @ MatrixMath::dot()\n");
Yo_Robot 3:48754fe86e08 201 }
mori3rti 6:aa5e94cddb3f 202 }
mori3rti 6:aa5e94cddb3f 203 else
mori3rti 6:aa5e94cddb3f 204 {
mori3rti 6:aa5e94cddb3f 205 if (leftM._nRows == rightM._nRows)
Yo_Robot 3:48754fe86e08 206 {
Yo_Robot 3:48754fe86e08 207 // Calculate (n, 1)( n, 1 )
Yo_Robot 3:48754fe86e08 208 float dotP;
Yo_Robot 3:48754fe86e08 209 Matrix Cross;
Yo_Robot 3:48754fe86e08 210
mori3rti 6:aa5e94cddb3f 211 Cross = MatrixMath::Transpose(leftM) * rightM;
Yo_Robot 3:48754fe86e08 212 dotP = Cross.sum();
Yo_Robot 3:48754fe86e08 213
Yo_Robot 3:48754fe86e08 214 return dotP;
mori3rti 6:aa5e94cddb3f 215 }
mori3rti 6:aa5e94cddb3f 216 else
mori3rti 6:aa5e94cddb3f 217 {
mori3rti 6:aa5e94cddb3f 218 printf("\n\nERROR:\n Matrices have diferent depths @ MatrixMath::dot()\n");
Yo_Robot 3:48754fe86e08 219 }
Yo_Robot 3:48754fe86e08 220 }
Yo_Robot 3:48754fe86e08 221 }
mori3rti 6:aa5e94cddb3f 222 }
mori3rti 6:aa5e94cddb3f 223 else
mori3rti 6:aa5e94cddb3f 224 {
mori3rti 6:aa5e94cddb3f 225 printf("\n\nERROR:\n Matrix is not a Vector @ MatrixMath::dot()\n");
Yo_Robot 3:48754fe86e08 226 }
Yo_Robot 3:48754fe86e08 227 }
Yo_Robot 3:48754fe86e08 228
mori3rti 6:aa5e94cddb3f 229 float MatrixMath::det(const Matrix &Mat)
Yo_Robot 3:48754fe86e08 230 {
mori3rti 6:aa5e94cddb3f 231 if (Mat._nRows == Mat._nCols)
Yo_Robot 3:48754fe86e08 232 {
Yo_Robot 3:48754fe86e08 233
mori3rti 6:aa5e94cddb3f 234 if (Mat._nRows == 2) // 2x2 Matrix
Yo_Robot 3:48754fe86e08 235 {
Yo_Robot 3:48754fe86e08 236 float det;
Yo_Robot 3:48754fe86e08 237 det = Mat._matrix[0][0] * Mat._matrix[1][1] -
mori3rti 6:aa5e94cddb3f 238 Mat._matrix[1][0] * Mat._matrix[0][1];
Yo_Robot 3:48754fe86e08 239 return det;
Yo_Robot 3:48754fe86e08 240 }
mori3rti 6:aa5e94cddb3f 241 else if (Mat._nRows == 3) // 3x3 Matrix
Yo_Robot 3:48754fe86e08 242 {
Yo_Robot 3:48754fe86e08 243 float det;
Yo_Robot 5:93948a9bbde2 244 MatrixMath dummy; //For Private Method.
Yo_Robot 3:48754fe86e08 245
mori3rti 6:aa5e94cddb3f 246 det = dummy.Det3x3(Mat);
Yo_Robot 3:48754fe86e08 247 return det;
mori3rti 6:aa5e94cddb3f 248 }
mori3rti 6:aa5e94cddb3f 249 else
mori3rti 6:aa5e94cddb3f 250 {
Yo_Robot 3:48754fe86e08 251
mori3rti 6:aa5e94cddb3f 252 float part1 = 0;
mori3rti 6:aa5e94cddb3f 253 float part2 = 0;
Yo_Robot 3:48754fe86e08 254
Yo_Robot 3:48754fe86e08 255 //Find +/- on First Row
mori3rti 6:aa5e94cddb3f 256 for (int i = 0; i < Mat._nCols; i++)
Yo_Robot 3:48754fe86e08 257 {
mori3rti 6:aa5e94cddb3f 258 Matrix reduced(Mat); // Copy Original Matrix
mori3rti 6:aa5e94cddb3f 259 Matrix::DeleteRow(reduced, 1); // Delete First Row
Yo_Robot 3:48754fe86e08 260
mori3rti 6:aa5e94cddb3f 261 if (i % 2 == 0) //Even Rows
Yo_Robot 3:48754fe86e08 262 {
Yo_Robot 3:48754fe86e08 263
mori3rti 6:aa5e94cddb3f 264 Matrix::DeleteCol(reduced, i + 1);
Yo_Robot 3:48754fe86e08 265 part1 += Mat._matrix[0][i] * MatrixMath::det(reduced);
Yo_Robot 3:48754fe86e08 266 }
mori3rti 6:aa5e94cddb3f 267 else // Odd Rows
Yo_Robot 3:48754fe86e08 268 {
mori3rti 6:aa5e94cddb3f 269 Matrix::DeleteCol(reduced, i + 1);
Yo_Robot 3:48754fe86e08 270 part2 += Mat._matrix[0][i] * MatrixMath::det(reduced);
Yo_Robot 3:48754fe86e08 271 }
Yo_Robot 3:48754fe86e08 272 }
mori3rti 6:aa5e94cddb3f 273 return part1 - part2;
Yo_Robot 3:48754fe86e08 274 }
mori3rti 6:aa5e94cddb3f 275 }
mori3rti 6:aa5e94cddb3f 276 else
mori3rti 6:aa5e94cddb3f 277 {
Yo_Robot 5:93948a9bbde2 278 printf("\n\nERROR:\nMatrix must be square Matrix @ MatrixMath::det");
Yo_Robot 3:48754fe86e08 279 }
Yo_Robot 3:48754fe86e08 280 }
Yo_Robot 3:48754fe86e08 281
mori3rti 6:aa5e94cddb3f 282 Matrix MatrixMath::kron(const Matrix &Mat_A, const Matrix &Mat_B)
mori3rti 6:aa5e94cddb3f 283 {
mori3rti 6:aa5e94cddb3f 284 Matrix result(Mat_A._nRows * Mat_B._nRows, Mat_A._nCols * Mat_B._nCols);
mori3rti 6:aa5e94cddb3f 285 for (unsigned int row_a = 0; row_a < Mat_A._nRows; row_a++)
mori3rti 6:aa5e94cddb3f 286 {
mori3rti 6:aa5e94cddb3f 287 for (unsigned int col_a = 0; col_a < Mat_A._nCols; col_a++)
mori3rti 6:aa5e94cddb3f 288 {
mori3rti 6:aa5e94cddb3f 289 Matrix block = Mat_A._matrix[row_a][col_a]*Mat_B;
mori3rti 6:aa5e94cddb3f 290
mori3rti 6:aa5e94cddb3f 291 for (unsigned int row_b = 0; row_b < Mat_B._nRows; row_b++)
mori3rti 6:aa5e94cddb3f 292 {
mori3rti 6:aa5e94cddb3f 293 for (unsigned int col_b = 0; col_b < Mat_B._nCols; col_b++)
mori3rti 6:aa5e94cddb3f 294 {
mori3rti 6:aa5e94cddb3f 295 result._matrix[row_b + (row_a * Mat_B._nRows)][col_b + (col_a * Mat_B._nCols)] = block._matrix[row_b][col_b];
mori3rti 6:aa5e94cddb3f 296 }
mori3rti 6:aa5e94cddb3f 297 }
mori3rti 6:aa5e94cddb3f 298 }
mori3rti 6:aa5e94cddb3f 299 }
mori3rti 6:aa5e94cddb3f 300 return result;
mori3rti 6:aa5e94cddb3f 301 }
Yo_Robot 3:48754fe86e08 302
Yo_Robot 3:48754fe86e08 303 /************************************/
Yo_Robot 3:48754fe86e08 304
Yo_Robot 3:48754fe86e08 305 //Private Functions
Yo_Robot 3:48754fe86e08 306
Yo_Robot 3:48754fe86e08 307 /**@brief
Yo_Robot 3:48754fe86e08 308 * Expands the Matrix adding first and second column to the Matrix then
Yo_Robot 3:48754fe86e08 309 * performs the Algorithm.
Yo_Robot 3:48754fe86e08 310 * @param Mat
Yo_Robot 3:48754fe86e08 311 * @return Determinant
Yo_Robot 3:48754fe86e08 312 */
mori3rti 6:aa5e94cddb3f 313 float MatrixMath::Det3x3(const Matrix &Mat)
Yo_Robot 3:48754fe86e08 314 {
mori3rti 6:aa5e94cddb3f 315 Matrix D(Mat); //Copy Initial matrix
Yo_Robot 3:48754fe86e08 316
Yo_Robot 3:48754fe86e08 317 Matrix::AddCol(D, Matrix::ExportCol(Mat, 1), 4); //Repeat First Column
Yo_Robot 3:48754fe86e08 318 Matrix::AddCol(D, Matrix::ExportCol(Mat, 2), 5); //Repeat Second Column
Yo_Robot 3:48754fe86e08 319
Yo_Robot 3:48754fe86e08 320 float det = 0;
mori3rti 6:aa5e94cddb3f 321 for (int i = 0; i < 3; i++)
mori3rti 6:aa5e94cddb3f 322 det += D._matrix[0][i] * D._matrix[1][1 + i] * D._matrix[2][2 + i] - D._matrix[0][2 + i] * D._matrix[1][1 + i] * D._matrix[2][i];
Yo_Robot 3:48754fe86e08 323
Yo_Robot 3:48754fe86e08 324 return det;
Yo_Robot 1:c74cdf14aea2 325 }