diff --git a/data/072785fd927ff0fd180ce8b9cc00078f-20180321_140826713_p_cnf_320_1120.cnf b/data/072785fd927ff0fd180ce8b9cc00078f-20180321_140826713_p_cnf_320_1120.cnf new file mode 100644 index 0000000..a2bf222 --- /dev/null +++ b/data/072785fd927ff0fd180ce8b9cc00078f-20180321_140826713_p_cnf_320_1120.cnf @@ -0,0 +1,1121 @@ +p cnf 320 1120 +-38 113 -304 0 +142 -56 159 0 +128 -256 -204 0 +-90 -68 -9 0 +207 -118 -157 0 +157 -8 145 0 +228 -52 -133 0 +-47 237 16 0 +-41 309 -10 0 +-217 176 88 0 +291 -249 -312 0 +-60 -242 104 0 +116 -287 19 0 +80 -210 -264 0 +288 94 -7 0 +-306 -165 201 0 +257 50 150 0 +138 149 156 0 +93 44 270 0 +285 161 137 0 +-109 -266 -185 0 +-153 33 -85 0 +-145 -234 -257 0 +-96 -116 52 0 +-137 269 -225 0 +64 -288 281 0 +286 294 -114 0 +249 90 155 0 +165 -112 184 0 +-320 234 -97 0 +31 49 60 0 +174 185 229 0 +70 42 280 0 +134 295 -43 0 +-107 152 -6 0 +239 320 96 0 +-316 2 -111 0 +232 302 -44 0 +108 212 259 0 +-146 -32 217 0 +-149 -120 -205 0 +-286 -209 -281 0 +-258 303 -74 0 +-175 97 -16 0 +293 209 -223 0 +167 37 -83 0 +-265 124 66 0 +-92 115 24 0 +204 -224 106 0 +175 169 -260 0 +153 308 -236 0 +14 -88 -199 0 +92 -293 -141 0 +179 -186 297 0 +279 136 -154 0 +-220 287 299 0 +242 -219 304 0 +123 34 158 0 +-176 -18 59 0 +-159 -163 107 0 +58 224 271 0 +219 141 32 0 +25 -152 -31 0 +-36 -5 272 0 +-276 -80 111 0 +-155 79 146 0 +51 -309 43 0 +-317 -216 -33 0 +-106 10 -212 0 +-89 -20 18 0 +246 8 74 0 +-23 39 258 0 +264 -79 -1 0 +-65 187 -115 0 +-268 -57 173 0 +256 -84 -190 0 +-215 -117 -143 0 +-201 305 -200 0 +121 164 273 0 +46 -24 57 0 +-30 -28 313 0 +-310 -172 202 0 +-39 -46 -311 0 +122 -213 -59 0 +199 -100 -70 0 +-42 -297 -161 0 +85 -3 -166 0 +292 170 119 0 +-105 -101 236 0 +-108 133 315 0 +197 -104 -239 0 +178 61 -121 0 +261 132 131 0 +190 205 -291 0 +-315 103 -37 0 +-313 -255 98 0 +195 -130 -77 0 +-34 -296 84 0 +-113 -305 -282 0 +154 233 160 0 +-181 -187 275 0 +-184 83 -158 0 +40 -54 41 0 +28 -271 214 0 +-103 91 -162 0 +-253 192 203 0 +-250 12 181 0 +-13 263 -241 0 +120 20 -269 0 +216 -142 -164 0 +82 -71 -277 0 +222 13 125 0 +277 -156 144 0 +-40 105 194 0 +265 -180 206 0 +-298 -50 114 0 +36 -127 -119 0 +-25 186 1 0 +-129 69 -231 0 +-160 -167 -132 0 +241 63 67 0 +-12 -307 126 0 +220 162 -95 0 +-51 89 112 0 +-295 189 77 0 +118 -2 143 0 +182 316 298 0 +-53 230 238 0 +282 -262 225 0 +5 7 -66 0 +101 253 317 0 +-136 250 76 0 +200 -174 -98 0 +15 -283 -247 0 +-177 -170 -93 0 +45 65 266 0 +-235 99 -169 0 +227 226 171 0 +-246 -14 -126 0 +310 -274 -102 0 +-63 -206 -192 0 +-45 -285 -11 0 +223 -203 6 0 +87 213 -144 0 +9 180 -86 0 +30 -61 268 0 +-299 168 -240 0 +172 -151 100 0 +48 130 129 0 +-230 -29 -294 0 +127 95 73 0 +-251 -125 260 0 +-226 -173 -131 0 +71 -67 54 0 +-196 -300 151 0 +-244 208 23 0 +-171 247 -228 0 +-319 -238 -263 0 +-308 117 68 0 +-301 319 307 0 +-147 318 290 0 +312 -135 147 0 +-76 252 -261 0 +-211 306 -87 0 +254 -128 81 0 +-48 47 -292 0 +296 86 -314 0 +251 188 240 0 +-15 38 -91 0 +-252 17 289 0 +-150 163 177 0 +53 196 -19 0 +139 314 274 0 +-182 301 -208 0 +211 -134 -207 0 +231 -191 -4 0 +-124 -289 -197 0 +-198 -138 -58 0 +-278 -140 -318 0 +166 284 -178 0 +278 11 -279 0 +78 -270 243 0 +-229 102 193 0 +-267 -81 -227 0 +-188 -110 -78 0 +245 244 4 0 +-254 -275 29 0 +235 -183 -290 0 +-193 109 283 0 +267 -195 221 0 +-248 -273 -284 0 +-302 -194 -55 0 +-280 -222 210 0 +-49 -221 148 0 +-22 -27 262 0 +-218 -259 -139 0 +-189 -303 -69 0 +-75 -245 -233 0 +-168 -82 -237 0 +248 26 311 0 +183 22 -122 0 +27 -202 -123 0 +-94 -73 55 0 +-272 255 -62 0 +276 215 -26 0 +300 191 -17 0 +62 198 110 0 +-64 -243 3 0 +-148 75 -214 0 +140 135 -232 0 +-35 -72 21 0 +-179 -21 56 0 +218 72 -99 0 +35 142 -272 0 +-20 -266 -121 0 +245 152 220 0 +-118 80 -289 0 +70 -141 -122 0 +170 -251 -252 0 +37 -242 54 0 +-220 -100 -228 0 +-22 -250 -199 0 +-290 200 -178 0 +-287 -216 -261 0 +79 111 -312 0 +-273 -265 -17 0 +17 -72 1 0 +-314 -1 -286 0 +77 222 258 0 +-183 14 120 0 +273 33 -29 0 +-62 -109 -231 0 +157 -191 41 0 +9 114 -132 0 +-223 -57 -275 0 +194 241 29 0 +-256 -282 -188 0 +166 -27 -128 0 +-307 -157 -16 0 +174 307 -101 0 +275 305 215 0 +-98 15 -204 0 +46 254 -116 0 +-105 318 -247 0 +286 -21 -214 0 +-104 -140 -33 0 +140 -119 149 0 +108 128 24 0 +261 182 240 0 +143 72 -173 0 +195 294 -207 0 +-306 -283 -174 0 +-170 -222 246 0 +269 85 156 0 +223 -129 206 0 +272 -160 -270 0 +197 -267 -15 0 +-53 291 62 0 +178 -234 162 0 +53 264 -180 0 +233 -166 155 0 +-28 -217 -302 0 +138 -195 -23 0 +-107 136 -184 0 +78 -56 -169 0 +-249 -97 28 0 +-149 -80 -117 0 +-52 -136 -218 0 +-301 237 -212 0 +148 -294 116 0 +113 299 98 0 +179 -88 106 0 +-13 -113 306 0 +-67 214 -305 0 +-11 212 -51 0 +217 -77 -46 0 +-30 -95 129 0 +10 -84 268 0 +256 -41 50 0 +160 -14 -152 0 +-135 193 210 0 +100 -155 -145 0 +133 -175 -4 0 +-85 279 61 0 +173 -300 180 0 +103 -258 -94 0 +-311 124 298 0 +-78 -297 -278 0 +48 -24 -154 0 +-147 34 -93 0 +-18 -200 267 0 +64 -32 65 0 +234 105 123 0 +82 -197 31 0 +192 204 55 0 +308 -233 278 0 +-137 -123 -206 0 +207 -70 -313 0 +-291 221 -158 0 +199 -54 175 0 +283 -240 -276 0 +12 232 -6 0 +-102 26 218 0 +-274 -244 141 0 +-75 84 164 0 +-254 158 118 0 +-86 -82 4 0 +93 297 -36 0 +-65 -153 18 0 +-138 -202 40 0 +266 -262 169 0 +83 -3 102 0 +42 -35 -192 0 +-193 -143 25 0 +309 289 317 0 +-182 257 16 0 +-60 -260 -161 0 +-96 99 -79 0 +-40 59 216 0 +-229 36 56 0 +230 -112 -295 0 +251 -61 51 0 +184 23 -194 0 +13 -209 20 0 +-268 315 -257 0 +-259 -203 -103 0 +249 -25 183 0 +-111 122 -308 0 +262 -8 -264 0 +-37 287 277 0 +101 7 -106 0 +73 281 177 0 +-34 313 -232 0 +-66 -196 -58 0 +-156 75 -9 0 +58 2 150 0 +-150 -92 -288 0 +115 -318 209 0 +-190 -236 21 0 +60 3 -133 0 +250 -73 135 0 +-235 284 88 0 +91 -142 -144 0 +67 190 300 0 +-115 161 226 0 +236 202 -219 0 +126 -124 176 0 +-99 -255 188 0 +311 -241 104 0 +43 86 6 0 +35 -299 -177 0 +293 119 -42 0 +-110 295 196 0 +-230 -281 235 0 +147 27 145 0 +-315 -181 -296 0 +66 -316 144 0 +-50 274 -59 0 +228 296 -83 0 +63 -2 52 0 +208 -151 -285 0 +185 -38 191 0 +87 187 137 0 +-12 -279 -87 0 +-5 -64 30 0 +-43 -114 285 0 +247 -179 -246 0 +-19 244 -165 0 +-317 -269 -159 0 +-48 227 -68 0 +-130 181 19 0 +219 -211 -208 0 +-172 270 316 0 +252 -310 71 0 +189 -320 213 0 +-186 8 107 0 +-237 125 69 0 +172 -213 5 0 +225 -189 304 0 +-91 97 -225 0 +255 -31 165 0 +49 121 320 0 +22 57 263 0 +109 -55 167 0 +301 -280 186 0 +229 302 303 0 +290 130 -127 0 +312 -187 288 0 +44 -304 -164 0 +159 39 260 0 +96 45 -39 0 +92 -171 -146 0 +-198 -263 239 0 +-210 -89 253 0 +-10 95 -125 0 +168 -26 -176 0 +-284 -224 -108 0 +-44 -163 32 0 +76 -277 81 0 +-319 89 211 0 +-69 265 203 0 +-7 127 139 0 +163 -239 -215 0 +-47 -126 276 0 +-90 -71 238 0 +94 112 -185 0 +146 -303 -81 0 +319 310 74 0 +-167 280 292 0 +259 -227 -74 0 +-131 110 -63 0 +-201 242 90 0 +-168 -148 -120 0 +-309 -248 -292 0 +131 -205 -293 0 +198 154 117 0 +-245 -76 224 0 +134 -221 -226 0 +68 -49 231 0 +-45 205 201 0 +282 -298 -134 0 +-238 132 38 0 +171 248 -139 0 +314 271 -253 0 +11 -271 153 0 +-162 -243 151 0 +243 47 204 0 +-29 -102 -169 0 +-75 -146 101 0 +42 169 -40 0 +178 -198 313 0 +-255 -273 92 0 +289 -88 255 0 +-253 -256 310 0 +-90 193 311 0 +184 -35 -318 0 +197 207 205 0 +31 83 -108 0 +302 318 -143 0 +-65 15 -46 0 +232 -306 234 0 +43 33 202 0 +-251 -165 -225 0 +10 138 -63 0 +315 58 -70 0 +-262 73 -303 0 +-15 251 59 0 +-21 34 -122 0 +-16 185 158 0 +176 262 93 0 +-73 80 188 0 +-147 -219 160 0 +228 -180 -157 0 +-96 -297 236 0 +-320 -202 89 0 +-11 102 269 0 +69 25 163 0 +128 143 -125 0 +-150 222 140 0 +-215 -222 -188 0 +-60 245 -139 0 +-238 -159 172 0 +-53 44 -299 0 +214 -213 -206 0 +-196 -57 -79 0 +-269 -5 -141 0 +122 -240 90 0 +-128 200 14 0 +256 275 -270 0 +11 -25 320 0 +134 180 286 0 +230 46 -93 0 +271 -197 -235 0 +5 304 -209 0 +-200 194 -228 0 +-278 281 268 0 +-84 115 211 0 +-31 -131 -185 0 +-260 26 -315 0 +199 -232 -205 0 +142 -80 64 0 +-47 -310 -45 0 +209 -101 312 0 +-112 57 37 0 +-129 257 272 0 +-117 285 217 0 +-140 -98 -154 0 +-97 -248 238 0 +-83 196 45 0 +-105 161 109 0 +-271 -156 231 0 +117 -307 60 0 +4 215 147 0 +-59 -302 -289 0 +111 74 -237 0 +270 -10 303 0 +-44 29 -298 0 +78 -74 -19 0 +91 -120 -263 0 +-111 284 297 0 +192 -13 75 0 +159 12 -28 0 +-276 252 -295 0 +129 -100 -66 0 +-204 -86 -230 0 +241 50 -94 0 +-172 -130 175 0 +-211 -266 -6 0 +13 -110 -181 0 +-104 -89 -9 0 +-312 -95 225 0 +-314 77 220 0 +309 133 135 0 +156 -56 -296 0 +-92 314 -176 0 +-319 -177 52 0 +53 254 -284 0 +-229 -43 277 0 +-218 132 -192 0 +65 2 -127 0 +307 -300 248 0 +221 -236 181 0 +-258 -272 -87 0 +126 -201 145 0 +-69 110 166 0 +-160 -41 -115 0 +-245 113 -268 0 +-72 165 149 0 +104 56 -290 0 +167 294 249 0 +108 -137 -293 0 +-32 218 -134 0 +66 -317 98 0 +276 97 82 0 +-193 95 -4 0 +-287 -311 191 0 +317 94 157 0 +139 -68 88 0 +164 120 114 0 +105 86 201 0 +246 -294 -243 0 +-249 112 141 0 +-163 291 -279 0 +-18 -113 -106 0 +-161 28 -8 0 +-77 198 -3 0 +-316 -207 -62 0 +-71 -58 243 0 +-36 -22 -252 0 +-214 240 154 0 +179 -12 287 0 +103 8 -173 0 +-20 32 -34 0 +81 -194 16 0 +-274 130 168 0 +35 -267 -313 0 +263 136 229 0 +9 -37 62 0 +-133 -254 -38 0 +-203 278 18 0 +-175 -277 -2 0 +239 253 152 0 +-210 -221 -199 0 +49 -135 -179 0 +264 -23 131 0 +-24 -282 265 0 +261 99 41 0 +79 219 -158 0 +-234 -259 183 0 +127 299 -280 0 +48 -283 151 0 +-151 233 260 0 +-190 -33 -30 0 +-81 298 63 0 +292 -178 -114 0 +121 206 -91 0 +-250 -244 273 0 +76 235 -121 0 +24 85 -285 0 +-217 -239 283 0 +-309 -55 -242 0 +22 190 -132 0 +-119 208 -49 0 +20 280 -162 0 +23 -153 -191 0 +-118 -261 -67 0 +-233 -183 137 0 +70 -281 -164 0 +-78 -1 -85 0 +-186 -52 258 0 +242 -301 7 0 +250 173 71 0 +237 87 -170 0 +96 290 -54 0 +-264 54 267 0 +301 150 67 0 +274 177 295 0 +-82 308 -27 0 +-304 -152 195 0 +-224 -14 -42 0 +-50 -142 -246 0 +224 1 -195 0 +182 -136 19 0 +203 186 -241 0 +-308 288 -167 0 +116 -109 -187 0 +-288 174 148 0 +38 226 279 0 +300 27 -216 0 +-138 282 227 0 +61 -107 216 0 +17 47 306 0 +-48 21 -145 0 +-231 -226 -220 0 +-168 162 68 0 +-64 305 124 0 +-182 170 -305 0 +-7 -126 125 0 +-265 187 -212 0 +266 100 36 0 +-76 -148 3 0 +293 155 210 0 +55 118 -144 0 +51 123 -124 0 +144 -174 153 0 +146 119 30 0 +296 106 -155 0 +212 72 -223 0 +319 -26 40 0 +-291 213 -99 0 +-123 -149 -103 0 +223 39 247 0 +259 -166 -184 0 +-51 -17 -208 0 +-116 -257 -292 0 +-227 -275 189 0 +107 316 -247 0 +-61 244 -171 0 +-189 6 -286 0 +84 -39 182 0 +171 34 169 0 +-96 302 -286 0 +226 284 258 0 +-95 -16 3 0 +-38 45 301 0 +-171 254 86 0 +-60 -190 -40 0 +148 -273 -170 0 +-8 295 90 0 +-86 -213 -125 0 +-84 -162 -197 0 +232 170 -245 0 +190 233 -135 0 +149 139 -25 0 +-290 -57 -182 0 +155 -127 273 0 +76 -313 209 0 +167 -19 282 0 +142 -242 -275 0 +85 -253 -318 0 +-319 -107 -231 0 +-223 82 53 0 +-297 294 -133 0 +199 227 -174 0 +-250 293 -295 0 +288 -53 -48 0 +77 111 -279 0 +-311 -88 266 0 +-293 4 -29 0 +-249 223 -262 0 +277 275 30 0 +305 157 -43 0 +246 -267 163 0 +132 166 211 0 +162 286 -181 0 +-314 -71 -309 0 +108 -277 -288 0 +103 -235 92 0 +-34 -233 15 0 +-205 74 -176 0 +-274 -145 153 0 +222 38 -203 0 +274 91 31 0 +189 40 20 0 +230 -111 174 0 +88 -159 -158 0 +-76 -259 269 0 +245 122 110 0 +-209 -90 -63 0 +126 -189 -31 0 +-41 -1 172 0 +171 237 59 0 +-148 -126 107 0 +-236 -280 -152 0 +-117 -287 203 0 +-102 200 -312 0 +164 -23 -204 0 +264 127 -141 0 +81 87 135 0 +184 -100 -261 0 +-237 313 314 0 +213 -85 -200 0 +26 -160 201 0 +-186 -146 -206 0 +267 -307 10 0 +-11 315 210 0 +-153 159 -211 0 +-132 64 8 0 +33 37 306 0 +69 -98 52 0 +-163 41 -165 0 +-210 -270 -124 0 +158 7 -300 0 +-55 -69 235 0 +-232 116 192 0 +-21 -226 -230 0 +205 -218 -243 0 +-296 61 -294 0 +39 -122 -306 0 +289 -109 -221 0 +253 161 299 0 +-118 -112 198 0 +319 100 187 0 +-175 93 141 0 +51 207 129 0 +-202 -278 307 0 +221 50 -269 0 +-82 279 143 0 +292 175 -72 0 +-192 -183 -283 0 +58 -234 -303 0 +249 285 -150 0 +-89 -292 -64 0 +-240 -268 -12 0 +297 -173 -256 0 +-164 -151 94 0 +-167 -75 -50 0 +-105 -156 112 0 +-198 84 -244 0 +102 234 -144 0 +206 -68 -136 0 +-101 -254 -26 0 +-35 304 196 0 +83 73 13 0 +63 179 -252 0 +262 -220 -238 0 +-28 -18 -80 0 +-116 43 -149 0 +138 242 -137 0 +-143 270 -120 0 +-37 176 214 0 +19 49 150 0 +-216 218 -5 0 +42 -65 -302 0 +-27 98 80 0 +-264 168 -147 0 +-47 -22 18 0 +35 268 -320 0 +99 -207 -168 0 +75 -215 228 0 +252 280 278 0 +-227 -83 -51 0 +178 185 310 0 +290 188 308 0 +-30 -24 -246 0 +-3 55 -36 0 +21 -45 -282 0 +124 -169 320 0 +60 -276 186 0 +303 208 -291 0 +240 -317 -32 0 +-178 115 287 0 +-92 -179 -129 0 +28 57 -81 0 +151 101 -108 0 +-285 -56 261 0 +123 -255 -44 0 +-7 32 256 0 +2 12 -212 0 +-106 -161 120 0 +16 96 160 0 +-139 195 173 0 +113 25 243 0 +-66 -103 109 0 +128 225 -239 0 +-188 238 -195 0 +-67 9 130 0 +-52 -304 47 0 +300 -177 -39 0 +114 -266 276 0 +-131 121 5 0 +-128 -316 -4 0 +27 65 -74 0 +-94 -61 183 0 +-33 -196 68 0 +-228 137 125 0 +66 -54 -248 0 +-97 -87 -10 0 +291 281 -193 0 +-180 -42 -110 0 +6 -142 154 0 +89 -298 78 0 +-91 309 -224 0 +-201 46 224 0 +118 311 1 0 +180 197 -260 0 +-59 23 181 0 +259 44 -305 0 +22 -77 -191 0 +-310 -217 140 0 +56 -299 97 0 +-284 -138 147 0 +-13 -208 133 0 +-258 -9 165 0 +-113 -93 136 0 +106 248 -123 0 +-301 -6 -308 0 +215 14 134 0 +79 271 250 0 +-229 -219 260 0 +-187 54 -119 0 +212 318 298 0 +156 257 29 0 +239 105 -73 0 +146 -272 -185 0 +-130 -184 -289 0 +229 247 255 0 +-115 36 -222 0 +17 241 220 0 +317 117 -121 0 +-214 -247 -104 0 +-257 236 104 0 +283 177 202 0 +152 -265 -281 0 +-17 -154 -134 0 +-15 -99 -199 0 +-225 -78 67 0 +204 72 -315 0 +193 -251 131 0 +-2 145 263 0 +265 -62 71 0 +219 231 -140 0 +251 -114 -271 0 +244 -14 -241 0 +11 62 119 0 +217 316 -49 0 +-172 -166 -58 0 +296 -46 95 0 +-79 191 -20 0 +48 70 -194 0 +144 24 -155 0 +312 -157 272 0 +216 -263 -265 0 +-70 132 -215 0 +194 43 270 0 +45 148 -70 0 +269 -16 186 0 +-211 82 -199 0 +-118 -260 203 0 +-13 -71 -123 0 +-290 -270 -42 0 +-311 59 62 0 +99 -18 75 0 +136 281 -178 0 +-223 -54 -148 0 +-250 34 -246 0 +13 288 231 0 +-249 -229 -170 0 +-181 51 -239 0 +-146 184 311 0 +-151 195 298 0 +286 185 -46 0 +-276 -180 -115 0 +143 -259 30 0 +-202 -165 314 0 +-101 -129 198 0 +246 208 -139 0 +128 294 240 0 +165 155 -297 0 +277 -106 -17 0 +-65 -112 135 0 +152 9 28 0 +-19 -105 -142 0 +80 -150 162 0 +-45 312 -55 0 +-152 295 -234 0 +164 -36 8 0 +-97 -314 117 0 +176 -52 -128 0 +64 26 -87 0 +-243 -217 213 0 +-153 217 -67 0 +-235 -282 -143 0 +134 18 -119 0 +115 -23 -189 0 +291 282 -277 0 +-186 55 181 0 +-35 243 215 0 +276 166 -272 0 +61 302 41 0 +97 42 6 0 +168 -302 -198 0 +263 7 -285 0 +31 -175 57 0 +232 111 -121 0 +-294 272 193 0 +-62 81 -93 0 +228 -205 202 0 +54 226 -155 0 +122 10 24 0 +-288 -316 40 0 +108 -220 -214 0 +-319 289 95 0 +154 -31 -256 0 +-216 -267 280 0 +223 -162 157 0 +221 271 52 0 +-30 93 -192 0 +-281 -41 -266 0 +-20 212 297 0 +91 70 101 0 +161 -232 -213 0 +-212 -86 -177 0 +118 247 -164 0 +-80 -218 194 0 +103 -147 3 0 +112 44 -224 0 +147 -7 -287 0 +124 224 211 0 +-89 76 190 0 +20 207 142 0 +188 126 -39 0 +149 -160 -82 0 +222 -44 -21 0 +279 139 35 0 +125 -190 156 0 +-231 16 252 0 +175 -301 -207 0 +-102 65 206 0 +-157 -208 -176 0 +-238 233 104 0 +129 -291 -240 0 +249 21 -278 0 +-51 -262 -5 0 +-61 -98 293 0 +-252 -75 48 0 +-132 79 -307 0 +-248 -134 -76 0 +-90 -300 -91 0 +-295 -88 292 0 +-122 -221 229 0 +-64 23 179 0 +-127 50 -254 0 +-166 241 -286 0 +-293 -81 278 0 +63 234 -219 0 +300 -251 -104 0 +127 71 39 0 +19 -11 90 0 +-289 -110 -145 0 +-159 -29 -73 0 +284 262 -194 0 +-126 113 -63 0 +105 87 67 0 +-156 308 172 0 +-40 -203 -292 0 +-108 219 121 0 +-241 37 -32 0 +-313 -193 -60 0 +-26 77 78 0 +-53 200 -179 0 +316 116 -131 0 +-120 -77 187 0 +204 307 266 0 +-163 230 109 0 +214 -109 296 0 +313 153 120 0 +-1 -317 -116 0 +-107 138 22 0 +265 -99 60 0 +-168 189 245 0 +-96 309 107 0 +-78 -100 -154 0 +-204 -137 145 0 +12 33 -74 0 +-47 163 -79 0 +-309 318 218 0 +49 -184 -38 0 +-263 4 304 0 +-125 250 167 0 +36 -268 225 0 +-255 216 315 0 +-236 69 -83 0 +114 -27 159 0 +-196 -56 -133 0 +182 14 238 0 +256 -68 -228 0 +100 -320 251 0 +-245 197 -37 0 +169 -258 267 0 +-185 137 -271 0 +123 -49 -59 0 +-242 -253 72 0 +-244 180 259 0 +-173 -144 -222 0 +287 -169 -201 0 +201 -28 133 0 +73 -191 92 0 +-312 173 -306 0 +-117 254 47 0 +235 1 319 0 +248 -310 -69 0 +-33 -188 160 0 +192 -308 305 0 +2 53 -114 0 +-9 -113 -318 0 +15 -161 -305 0 +94 306 -210 0 +275 96 -103 0 +-94 -182 86 0 +58 290 -225 0 +27 -195 -136 0 +260 -200 191 0 +-48 -124 244 0 +268 -158 -298 0 +-233 303 88 0 +-4 227 261 0 +264 46 151 0 +-84 299 -269 0 +-274 205 -315 0 +85 -6 -15 0 +-92 -261 -279 0 +177 -226 -22 0 +-43 237 84 0 +320 -130 -8 0 +-24 32 -58 0 +285 89 220 0 +178 301 29 0 +-283 -50 110 0 +17 257 68 0 +11 -247 -284 0 +-264 170 239 0 +196 -237 -183 0 +-206 -167 56 0 +-66 -12 274 0 +-197 -187 -303 0 +-304 317 -230 0 +-138 38 255 0 +-2 5 183 0 +98 -57 -3 0 +-280 102 -149 0 +-111 106 48 0 +25 74 144 0 +-257 310 -209 0 +130 253 -171 0 +131 -34 242 0 +-25 -273 -10 0 +150 -275 -1 0 +-72 -95 -174 0 +209 283 273 0 +-141 -227 -52 0 +83 258 119 0 +210 206 208 0 +66 146 -85 0 +236 171 -95 0 +158 -135 -299 0 +-14 -296 -140 0 +199 17 -114 0 +-172 174 -34 0 +140 93 -137 0 +141 233 -109 0 +-11 -101 57 0 +-120 261 -230 0 +-282 -140 101 0 +-71 -112 307 0 +-107 254 205 0 +-41 12 62 0 +-236 -53 -77 0 +-36 59 -152 0 +52 34 285 0 +252 37 -143 0 +293 -75 320 0 +-254 -12 69 0 +-106 -272 -264 0 +113 95 142 0 +-201 288 -134 0 +-151 -28 92 0 +184 214 310 0 +-274 63 -275 0 +112 114 303 0 +-48 149 -266 0 +-311 -141 162 0 +167 43 209 0 +53 274 -89 0 +-86 -233 -218 0 +284 -216 -125 0 +106 78 4 0 +230 -130 -208 0 +212 225 160 0 +-165 195 56 0 +-159 40 -51 0 +-129 120 -96 0 +174 182 135 0 +-160 299 173 0 +193 189 27 0 +-284 -314 -298 0 +103 -276 -46 0 +-223 -219 -59 0 +204 148 -318 0 +-242 74 151 0 +128 45 234 0 +-184 315 -18 0 +-252 -171 286 0 +73 -297 -168 0 +26 -13 172 0 +-149 -189 -238 0 +-195 83 -273 0 +-244 -172 65 0 +-248 305 36 0 +238 297 -98 0 diff --git a/kissat-inc/makefile b/kissat-inc/makefile index 37626dd..8e4ab81 100644 --- a/kissat-inc/makefile +++ b/kissat-inc/makefile @@ -1,17 +1,17 @@ all: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" kissat: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" kissat + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" kissat tissat: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" tissat + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" tissat clean: - rm -f "/pub/netdisk1/qianyh/Light/kissat-inc"/makefile - -$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" clean - rm -rf "/pub/netdisk1/qianyh/Light/kissat-inc/build" + rm -f "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc"/makefile + -$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" clean + rm -rf "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" coverage: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" coverage + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" coverage indent: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" indent + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" indent test: - $(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" test + $(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" test .PHONY: all clean coverage indent kissat test tissat diff --git a/lstech_maple/LICENSE b/lstech_maple/LICENSE new file mode 100755 index 0000000..d5ecee5 --- /dev/null +++ b/lstech_maple/LICENSE @@ -0,0 +1,38 @@ + +/*************************************************************************************** +MIT LICENSE + +lstech_maple, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang. +Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT. +Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing. + +MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c) 2019, Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters. + +MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c) 2018, Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ \ No newline at end of file diff --git a/lstech_maple/Makefile b/lstech_maple/Makefile new file mode 100755 index 0000000..8878e5d --- /dev/null +++ b/lstech_maple/Makefile @@ -0,0 +1,215 @@ +################################################################################################### + +.PHONY: r d p sh cr cd cp csh lr ld lp lsh config all install install-headers install-lib\ + install-bin clean distclean +all: r lr lsh + +## Load Previous Configuration #################################################################### + +-include config.mk + +## Configurable options ########################################################################### + +# Directory to store object files, libraries, executables, and dependencies: +BUILD_DIR ?= build + +# Include debug-symbols in release builds +MAPLE_RELSYM ?= -g + +# Sets of compile flags for different build types +MAPLE_REL ?= -O3 -D NDEBUG +MAPLE_DEB ?= -O0 -D DEBUG +MAPLE_PRF ?= -O3 -D NDEBUG +MAPLE_FPIC ?= -fpic + +# GNU Standard Install Prefix +prefix ?= /usr/local + +## Write Configuration ########################################################################### + +config: + @( echo 'BUILD_DIR?=$(BUILD_DIR)' ; \ + echo 'MAPLE_RELSYM?=$(MAPLE_RELSYM)' ; \ + echo 'MAPLE_REL?=$(MAPLE_REL)' ; \ + echo 'MAPLE_DEB?=$(MAPLE_DEB)' ; \ + echo 'MAPLE_PRF?=$(MAPLE_PRF)' ; \ + echo 'MAPLE_FPIC?=$(MAPLE_FPIC)' ; \ + echo 'prefix?=$(prefix)' ) > config.mk + +## Configurable options end ####################################################################### + +INSTALL ?= install + +# GNU Standard Install Variables +exec_prefix ?= $(prefix) +includedir ?= $(prefix)/include +bindir ?= $(exec_prefix)/bin +libdir ?= $(exec_prefix)/lib +datarootdir ?= $(prefix)/share +mandir ?= $(datarootdir)/man + +# Target file names +MAPLE = lstech# Name of MiniSat main executable. +MAPLE_CORE = lstech_core# Name of simplified MiniSat executable (only core solver support). +MAPLE_SLIB = lib$(MAPLE).a# Name of MiniSat static library. +MAPLE_DLIB = lib$(MAPLE).so# Name of MiniSat shared library. + +# Shared Library Version +SOMAJOR=2 +SOMINOR=1 +SORELEASE?=.0# Declare empty to leave out from library file name. + +MAPLE_CXXFLAGS = -I. -Ilstech/ -D __STDC_LIMIT_MACROS -D __STDC_FORMAT_MACROS -Wall -Wno-parentheses -Wextra -std=c++11 +MAPLE_LDFLAGS = -Wall -lz + +ECHO=@echo +ifeq ($(VERB),) +VERB=@ +else +VERB= +endif + +SRCS = $(wildcard lstech/core/*.cc) $(wildcard lstech/simp/*.cc) $(wildcard lstech/utils/*.cc) +HDRS = $(wildcard lstech/mtl/*.h) $(wildcard lstech/core/*.h) $(wildcard lstech/simp/*.h) $(wildcard lstech/utils/*.h) +OBJS = $(filter-out %Main.o, $(SRCS:.cc=.o)) + +r: $(BUILD_DIR)/release/bin/$(MAPLE) +d: $(BUILD_DIR)/debug/bin/$(MAPLE) +p: $(BUILD_DIR)/profile/bin/$(MAPLE) +sh: $(BUILD_DIR)/dynamic/bin/$(MAPLE) + +cr: $(BUILD_DIR)/release/bin/$(MAPLE_CORE) +cd: $(BUILD_DIR)/debug/bin/$(MAPLE_CORE) +cp: $(BUILD_DIR)/profile/bin/$(MAPLE_CORE) +csh: $(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE) + +lr: $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) +ld: $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) +lp: $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB) +lsh: $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) + +## Build-type Compile-flags: +$(BUILD_DIR)/release/%.o: MAPLE_CXXFLAGS +=$(MAPLE_REL) $(MAPLE_RELSYM) +$(BUILD_DIR)/debug/%.o: MAPLE_CXXFLAGS +=$(MAPLE_DEB) -g +$(BUILD_DIR)/profile/%.o: MAPLE_CXXFLAGS +=$(MAPLE_PRF) -pg +$(BUILD_DIR)/dynamic/%.o: MAPLE_CXXFLAGS +=$(MAPLE_REL) $(MAPLE_FPIC) + +## Build-type Link-flags: +$(BUILD_DIR)/profile/bin/$(MAPLE): MAPLE_LDFLAGS += -pg +$(BUILD_DIR)/release/bin/$(MAPLE): MAPLE_LDFLAGS += --static $(MAPLE_RELSYM) +$(BUILD_DIR)/profile/bin/$(MAPLE_CORE): MAPLE_LDFLAGS += -pg +$(BUILD_DIR)/release/bin/$(MAPLE_CORE): MAPLE_LDFLAGS += --static $(MAPLE_RELSYM) + +## Executable dependencies +$(BUILD_DIR)/release/bin/$(MAPLE): $(BUILD_DIR)/release/lstech/simp/Main.o $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) +$(BUILD_DIR)/debug/bin/$(MAPLE): $(BUILD_DIR)/debug/lstech/simp/Main.o $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) +$(BUILD_DIR)/profile/bin/$(MAPLE): $(BUILD_DIR)/profile/lstech/simp/Main.o $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB) +# need the main-file be compiled with fpic? +$(BUILD_DIR)/dynamic/bin/$(MAPLE): $(BUILD_DIR)/dynamic/lstech/simp/Main.o $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB) + +## Executable dependencies (core-version) +$(BUILD_DIR)/release/bin/$(MAPLE_CORE): $(BUILD_DIR)/release/lstech/core/Main.o $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) +$(BUILD_DIR)/debug/bin/$(MAPLE_CORE): $(BUILD_DIR)/debug/lstech/core/Main.o $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) +$(BUILD_DIR)/profile/bin/$(MAPLE_CORE): $(BUILD_DIR)/profile/lstech/core/Main.o $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB) +# need the main-file be compiled with fpic? +$(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE): $(BUILD_DIR)/dynamic/lstech/core/Main.o $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB) + +## Library dependencies +$(BUILD_DIR)/release/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/release/$(o)) +$(BUILD_DIR)/debug/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/debug/$(o)) +$(BUILD_DIR)/profile/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/profile/$(o)) +$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/dynamic/$(o)) + +## Compile rules (these should be unified, buit I have not yet found a way which works in GNU Make) +$(BUILD_DIR)/release/%.o: %.cc + $(ECHO) Compiling: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/release/$*.d + +$(BUILD_DIR)/profile/%.o: %.cc + $(ECHO) Compiling: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/profile/$*.d + +$(BUILD_DIR)/debug/%.o: %.cc + $(ECHO) Compiling: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/debug/$*.d + +$(BUILD_DIR)/dynamic/%.o: %.cc + $(ECHO) Compiling: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/dynamic/$*.d + +## Linking rule +$(BUILD_DIR)/release/bin/$(MAPLE) $(BUILD_DIR)/debug/bin/$(MAPLE) $(BUILD_DIR)/profile/bin/$(MAPLE) $(BUILD_DIR)/dynamic/bin/$(MAPLE)\ +$(BUILD_DIR)/release/bin/$(MAPLE_CORE) $(BUILD_DIR)/debug/bin/$(MAPLE_CORE) $(BUILD_DIR)/profile/bin/$(MAPLE_CORE) $(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE): + $(ECHO) Linking Binary: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $^ $(MAPLE_LDFLAGS) $(LDFLAGS) -o $@ + +## Static Library rule +%/lib/$(MAPLE_SLIB): + $(ECHO) Linking Static Library: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(AR) -rcs $@ $^ + +## Shared Library rule +$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB): + $(ECHO) Linking Shared Library: $@ + $(VERB) mkdir -p $(dir $@) + $(VERB) $(CXX) $(MAPLE_LDFLAGS) $(LDFLAGS) -o $@ -shared -Wl,-soname,$(MAPLE_DLIB).$(SOMAJOR) $^ + $(VERB) ln -sf $(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR) + $(VERB) ln -sf $(MAPLE_DLIB).$(SOMAJOR) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB) + +install: install-headers install-lib install-bin +install-debug: install-headers install-lib-debug + +install-headers: +# Create directories + $(INSTALL) -d $(DESTDIR)$(includedir)/lstech + for dir in mtl utils core simp; do \ + $(INSTALL) -d $(DESTDIR)$(includedir)/lstech/$$dir ; \ + done +# Install headers + for h in $(HDRS) ; do \ + $(INSTALL) -m 644 $$h $(DESTDIR)$(includedir)/$$h ; \ + done + +install-lib-debug: $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) + $(INSTALL) -d $(DESTDIR)$(libdir) + $(INSTALL) -m 644 $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) $(DESTDIR)$(libdir) + +install-lib: $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) + $(INSTALL) -d $(DESTDIR)$(libdir) + $(INSTALL) -m 644 $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(DESTDIR)$(libdir) + ln -sf $(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(DESTDIR)$(libdir)/$(MAPLE_DLIB).$(SOMAJOR) + ln -sf $(MAPLE_DLIB).$(SOMAJOR) $(DESTDIR)$(libdir)/$(MAPLE_DLIB) + $(INSTALL) -m 644 $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) $(DESTDIR)$(libdir) + +install-bin: $(BUILD_DIR)/dynamic/bin/$(MAPLE) + $(INSTALL) -d $(DESTDIR)$(bindir) + $(INSTALL) -m 755 $(BUILD_DIR)/dynamic/bin/$(MAPLE) $(DESTDIR)$(bindir) + +clean: + rm -rf $(foreach t, release debug profile dynamic, $(foreach o, $(SRCS:.cc=.o), $(BUILD_DIR)/$t/$o)) \ + $(foreach t, release debug profile dynamic, $(foreach d, $(SRCS:.cc=.d), $(BUILD_DIR)/$t/$d)) \ + $(foreach t, release debug profile dynamic, $(BUILD_DIR)/$t/bin/$(MAPLE_CORE) $(BUILD_DIR)/$t/bin/$(MAPLE)) \ + $(foreach t, release debug profile, $(BUILD_DIR)/$t/lib/$(MAPLE_SLIB)) \ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\ + $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB) \ + $(BUILD_DIR) + +distclean: clean + rm -f config.mk + +## Include generated dependencies +-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/release/$s) +-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/debug/$s) +-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/profile/$s) +-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/dynamic/$s) diff --git a/lstech_maple/README b/lstech_maple/README new file mode 100755 index 0000000..910d1b8 --- /dev/null +++ b/lstech_maple/README @@ -0,0 +1,32 @@ +How to build: + use the command "./starexec_build" + +How to use: + In the "bin" directory, + use the command "./lstech_maple " + e,g. ./lstech_maple ./simple_v3_c2.cnf + +The format of CNF: + the CNF format includes lines of 3-lines: + p-line: start with "p cnf ", followed by the number of variables and clauses. + c-line: comment lines. + clause-line: a clause can be represented by a series of numbers end with 0. + + For example: + c simple_v3_c2.cnf + c + p cnf 3 2 + 1 -3 0 + 2 3 -1 0 + + The details can be found in "https://people.sc.fsu.edu/~jburkardt/data/cnf/cnf.html" + +The output format: + c-line: comment lines + s-line: show the result of this call, SATISFIABLE UNSATISFIABLE or UNKNOWN. + v-line: show the model if SAT + + For example: + c result of simple_v3_c2.cnf + s SATISFIABLE + v 1 -2 3 0 \ No newline at end of file diff --git a/lstech_maple/bin/lstech_maple b/lstech_maple/bin/lstech_maple new file mode 100755 index 0000000..884d3f3 Binary files /dev/null and b/lstech_maple/bin/lstech_maple differ diff --git a/lstech_maple/lstech/.vscode/settings.json b/lstech_maple/lstech/.vscode/settings.json new file mode 100755 index 0000000..b6f8178 --- /dev/null +++ b/lstech_maple/lstech/.vscode/settings.json @@ -0,0 +1,54 @@ +{ + "files.associations": { + "ostream": "cpp", + "iosfwd": "cpp", + "cctype": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "array": "cpp", + "atomic": "cpp", + "*.tcc": "cpp", + "chrono": "cpp", + "cstdint": "cpp", + "deque": "cpp", + "unordered_map": "cpp", + "unordered_set": "cpp", + "vector": "cpp", + "exception": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "map": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "ratio": "cpp", + "set": "cpp", + "string": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "fstream": "cpp", + "initializer_list": "cpp", + "iostream": "cpp", + "istream": "cpp", + "limits": "cpp", + "new": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "cinttypes": "cpp", + "typeinfo": "cpp" + } +} \ No newline at end of file diff --git a/lstech_maple/lstech/core/Dimacs.h b/lstech_maple/lstech/core/Dimacs.h new file mode 100755 index 0000000..9550e04 --- /dev/null +++ b/lstech_maple/lstech/core/Dimacs.h @@ -0,0 +1,157 @@ +/****************************************************************************************[Dimacs.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Dimacs_h +#define Minisat_Dimacs_h + +#include + +#include "utils/ParseUtils.h" +#include "core/SolverTypes.h" + +namespace Minisat { + +//================================================================================================= +// DIMACS Parser: + +template +static void readClause(B& in, Solver& S, vec& lits) { + int parsed_lit, var; + lits.clear(); + for (;;){ + parsed_lit = parseInt(in); + if (parsed_lit == 0) break; + var = abs(parsed_lit)-1; + while (var >= S.nVars()) S.newVar(); + lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) ); + } +} + +template +static void parse_DIMACS_main(B& in, Solver& S) { + vec lits; + int vars = 0; + int clauses = 0; + int cnt = 0; + for (;;){ + skipWhitespace(in); + if (*in == EOF) break; + else if (*in == 'p'){ + if (eagerMatch(in, "p cnf")){ + vars = parseInt(in); + clauses = parseInt(in); + // SATRACE'06 hack + // if (clauses > 4000000) + // S.eliminate(true); + }else{ + printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3); + } + } else if (*in == 'c' || *in == 'p') + skipLine(in); + else{ + cnt++; + readClause(in, S, lits); + S.addClause_(lits); } + } + if (vars != S.nVars()) + fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n"); + if (cnt != clauses) + fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n"); +} + +// Inserts problem into solver. +// +template +static void parse_DIMACS(gzFile input_stream, Solver& S) { + StreamBuffer in(input_stream); + parse_DIMACS_main(in, S); } + +//================================================================================================= + +template +static void simple_readClause(B& in, Solver& S, vec& lits) { + int parsed_lit, var; + lits.clear(); + for (;;){ + parsed_lit = parseInt(in); + if (parsed_lit == 0) break; + var = abs(parsed_lit)-1; + lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) ); + } +} + +template +static void check_solution_DIMACS_main(B& in, Solver& S) { + vec lits; + int vars = 0; + int clauses = 0; + int cnt = 0; + bool ok=true; + for (;;){ + skipWhitespace(in); + if (*in == EOF) break; + else if (*in == 'p'){ + if (eagerMatch(in, "p cnf")){ + vars = parseInt(in); + clauses = parseInt(in); + // SATRACE'06 hack + // if (clauses > 4000000) + // S.eliminate(true); + }else{ + printf("c PARSE ERROR! Unexpected char: %c\n", *in), exit(3); + } + } else if (*in == 'c' || *in == 'p') + skipLine(in); + else{ + cnt++; + int parsed_lit, var; + bool ok=false; + for(;;) { + parsed_lit = parseInt(in); + if (parsed_lit == 0) break; //{printf("\n"); break;} + var = abs(parsed_lit)-1; + // printf("%d ", parsed_lit); + if ((parsed_lit>0 && S.model[var]==l_True) || + (parsed_lit<0 && S.model[var]==l_False)) + ok=true; + } + if (!ok) { + printf("c clause %d is not satisfied\n", cnt); + ok=false; + // break; + } + } + } + if (cnt != clauses) + printf("c WARNING! DIMACS header mismatch: wrong number of clauses.%d %d\n", cnt, clauses); + else if (ok) + printf("c solution checked against the original DIMACS file\n"); +} + +template +static void check_solution_DIMACS(gzFile input_stream, Solver& S) { + StreamBuffer in(input_stream); + check_solution_DIMACS_main(in, S); } + +//================================================================================================= +} + +#endif + diff --git a/lstech_maple/lstech/core/Main.cc b/lstech_maple/lstech/core/Main.cc new file mode 100755 index 0000000..bfa0007 --- /dev/null +++ b/lstech_maple/lstech/core/Main.cc @@ -0,0 +1,214 @@ +/***************************************************************************************[Solver.cc] +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include + +#include +#include + +#include "utils/System.h" +#include "utils/ParseUtils.h" +#include "utils/Options.h" +#include "core/Dimacs.h" +#include "core/Solver.h" + +using namespace Minisat; + +//================================================================================================= + + +void printStats(Solver& solver) +{ + double cpu_time = cpuTime(); + double mem_used = memUsedPeak(); + printf("c restarts : %"PRIu64"\n", solver.starts); + printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time); + printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time); + printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time); + printf("c conflict literals : %-12"PRIu64" (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals); + if (mem_used != 0) printf("c Memory used : %.2f MB\n", mem_used); + printf("c CPU time : %g s\n", cpu_time); +} + + +static Solver* solver; +// Terminate by notifying the solver and back out gracefully. This is mainly to have a test-case +// for this feature of the Solver as it may take longer than an immediate call to '_exit()'. +static void SIGINT_interrupt(int signum) { solver->interrupt(); } + +// Note that '_exit()' rather than 'exit()' has to be used. The reason is that 'exit()' calls +// destructors and may cause deadlocks if a malloc/free function happens to be running (these +// functions are guarded by locks for multithreaded use). +static void SIGINT_exit(int signum) { + printf("\n"); printf("c *** INTERRUPTED ***\n"); + if (solver->verbosity > 0){ + printStats(*solver); + printf("\n"); printf("c *** INTERRUPTED ***\n"); } + _exit(1); } + + +//================================================================================================= +// Main: + + +int main(int argc, char** argv) +{ + try { + setUsageHelp("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n"); + printf("c This is COMiniSatPS.\n"); + +#if defined(__linux__) + fpu_control_t oldcw, newcw; + _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); + printf("c WARNING: for repeatability, setting FPU to use double precision\n"); +#endif + // Extra options: + // + IntOption verb ("MAIN", "verb", "Verbosity level (0=silent, 1=some, 2=more).", 1, IntRange(0, 2)); + IntOption cpu_lim("MAIN", "cpu-lim","Limit on CPU time allowed in seconds.\n", INT32_MAX, IntRange(0, INT32_MAX)); + IntOption mem_lim("MAIN", "mem-lim","Limit on memory usage in megabytes.\n", INT32_MAX, IntRange(0, INT32_MAX)); + + parseOptions(argc, argv, true); + + Solver S; + double initial_time = cpuTime(); + + S.verbosity = verb; + + solver = &S; + // Use signal handlers that forcibly quit until the solver will be able to respond to + // interrupts: + signal(SIGINT, SIGINT_exit); + signal(SIGXCPU,SIGINT_exit); + + // Set limit on CPU-time: + if (cpu_lim != INT32_MAX){ + rlimit rl; + getrlimit(RLIMIT_CPU, &rl); + if (rl.rlim_max == RLIM_INFINITY || (rlim_t)cpu_lim < rl.rlim_max){ + rl.rlim_cur = cpu_lim; + if (setrlimit(RLIMIT_CPU, &rl) == -1) + printf("c WARNING! Could not set resource limit: CPU-time.\n"); + } } + + // Set limit on virtual memory: + if (mem_lim != INT32_MAX){ + rlim_t new_mem_lim = (rlim_t)mem_lim * 1024*1024; + rlimit rl; + getrlimit(RLIMIT_AS, &rl); + if (rl.rlim_max == RLIM_INFINITY || new_mem_lim < rl.rlim_max){ + rl.rlim_cur = new_mem_lim; + if (setrlimit(RLIMIT_AS, &rl) == -1) + printf("c WARNING! Could not set resource limit: Virtual memory.\n"); + } } + + if (argc == 1) + printf("c Reading from standard input... Use '--help' for help.\n"); + + gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb"); + if (in == NULL) + printf("c ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1); + + if (S.verbosity > 0){ + printf("c ============================[ Problem Statistics ]=============================\n"); + printf("c | |\n"); } + + parse_DIMACS(in, S); + gzclose(in); + FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL; + + if (S.verbosity > 0){ + printf("c | Number of variables: %12d |\n", S.nVars()); + printf("c | Number of clauses: %12d |\n", S.nClauses()); } + + double parsed_time = cpuTime(); + if (S.verbosity > 0){ + printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time); + printf("c | |\n"); } + + // Change to signal-handlers that will only notify the solver and allow it to terminate + // voluntarily: + signal(SIGINT, SIGINT_interrupt); + signal(SIGXCPU,SIGINT_interrupt); + + if (!S.simplify()){ + if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res); + if (S.verbosity > 0){ + printf("c ===============================================================================\n"); + printf("c Solved by unit propagation\n"); + printStats(S); + printf("\n"); } + printf("s UNSATISFIABLE\n"); + exit(20); + } + + vec dummy; + lbool ret = S.solveLimited(dummy); + if (S.verbosity > 0){ + printStats(S); + if (ret == l_True) { + in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb"); + // check_solution_DIMACS(in, S); + gzclose(in); + } + printf("\n"); } + printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n"); + if (ret == l_True){ + printf("v "); + for (int i = 0; i < S.nVars(); i++) + if (S.model[i] != l_Undef) + printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); + printf(" 0\n"); + } + + + if (res != NULL){ + if (ret == l_True){ + fprintf(res, "SAT\n"); + for (int i = 0; i < S.nVars(); i++) + if (S.model[i] != l_Undef) + fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); + fprintf(res, " 0\n"); + }else if (ret == l_False) + fprintf(res, "UNSAT\n"); + else + fprintf(res, "INDET\n"); + fclose(res); + } + +#ifdef NDEBUG + exit(ret == l_True ? 10 : ret == l_False ? 20 : 0); // (faster than "return", which will invoke the destructor for 'Solver') +#else + return (ret == l_True ? 10 : ret == l_False ? 20 : 0); +#endif + } catch (OutOfMemoryException&){ + printf("c ===============================================================================\n"); + printf("s UNKNOWN\n"); + exit(0); + } +} diff --git a/lstech_maple/lstech/core/Makefile b/lstech_maple/lstech/core/Makefile new file mode 100755 index 0000000..c724f55 --- /dev/null +++ b/lstech_maple/lstech/core/Makefile @@ -0,0 +1,5 @@ +EXEC = glucose +DEPDIR = mtl utils +MROOT = .. + +include $(MROOT)/mtl/template.mk diff --git a/lstech_maple/lstech/core/Solver.cc b/lstech_maple/lstech/core/Solver.cc new file mode 100755 index 0000000..f572ebe --- /dev/null +++ b/lstech_maple/lstech/core/Solver.cc @@ -0,0 +1,2831 @@ +/***************************************************************************************[Solver.cc] +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + +MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121. + +MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters. + +lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Xindi Zhang, Shaowei Cai +Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT. +Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing. + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include +#include +#include +#include +#include + +#include "mtl/Sort.h" +#include "core/Solver.h" +#include "utils/ccnr.h" +#include "utils/System.h" +using namespace Minisat; + +//#define PRINT_OUT + +#ifdef BIN_DRUP +int Solver::buf_len = 0; +unsigned char Solver::drup_buf[2 * 1024 * 1024]; +unsigned char* Solver::buf_ptr = drup_buf; +#endif + + +//================================================================================================= +// Options: + + +static const char* _cat = "CORE"; + +static DoubleOption opt_step_size (_cat, "step-size", "Initial step size", 0.40, DoubleRange(0, false, 1, false)); +static DoubleOption opt_step_size_dec (_cat, "step-size-dec","Step size decrement", 0.000001, DoubleRange(0, false, 1, false)); +static DoubleOption opt_min_step_size (_cat, "min-step-size","Minimal step size", 0.06, DoubleRange(0, false, 1, false)); +static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.80, DoubleRange(0, false, 1, false)); +static DoubleOption opt_clause_decay (_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false)); +static DoubleOption opt_random_var_freq (_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true)); +static DoubleOption opt_random_seed (_cat, "rnd-seed", "Used by the random variable selection", 91648253, DoubleRange(0, false, HUGE_VAL, false)); +static IntOption opt_ccmin_mode (_cat, "ccmin-mode", "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 2, IntRange(0, 2)); +static IntOption opt_phase_saving (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2)); +static BoolOption opt_rnd_init_act (_cat, "rnd-init", "Randomize the initial activity", false); +static IntOption opt_restart_first (_cat, "rfirst", "The base restart interval", 100, IntRange(1, INT32_MAX)); +static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 2, DoubleRange(1, false, HUGE_VAL, false)); +static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false)); +static IntOption opt_chrono (_cat, "chrono", "Controls if to perform chrono backtrack", 100, IntRange(-1, INT32_MAX)); +static IntOption opt_conf_to_chrono (_cat, "confl-to-chrono", "Controls number of conflicts to perform chrono backtrack", 4000, IntRange(-1, INT32_MAX)); + +static IntOption opt_max_lbd_dup ("DUP-LEARNTS", "lbd-limit", "specifies the maximum lbd of learnts to be screened for duplicates.", 14, IntRange(0, INT32_MAX)); +static IntOption opt_min_dupl_app ("DUP-LEARNTS", "min-dup-app", "specifies the minimum number of learnts to be included into db.", 2, IntRange(2, INT32_MAX)); +static IntOption opt_dupl_db_init_size ("DUP-LEARNTS", "dupdb-init", "specifies the initial maximal duplicates DB size.", 1000000, IntRange(1, INT32_MAX)); + + +//================================================================================================= +// Constructor/Destructor: + + +Solver::Solver() : + + // Parameters (user settable): + // + worker_index (-1) + , worker_number (-1) + , worker_seed (-1) + , drup_file (NULL) + , verbosity (0) + , step_size (opt_step_size) + , step_size_dec (opt_step_size_dec) + , min_step_size (opt_min_step_size) + , timer (5000) + , var_decay (opt_var_decay) + , clause_decay (opt_clause_decay) + , random_var_freq (opt_random_var_freq) + , random_seed (opt_random_seed) + , VSIDS (false) + , ccmin_mode (opt_ccmin_mode) + , phase_saving (opt_phase_saving) + , rnd_pol (false) + , rnd_init_act (opt_rnd_init_act) + , garbage_frac (opt_garbage_frac) + , restart_first (opt_restart_first) + , restart_inc (opt_restart_inc) + + + , min_number_of_learnts_copies(opt_min_dupl_app) + , max_lbd_dup(opt_max_lbd_dup) + , dupl_db_init_size(opt_dupl_db_init_size) + + // Parameters (the rest): + // + , learntsize_factor((double)1/(double)3), learntsize_inc(1.1) + + // Parameters (experimental): + // + , learntsize_adjust_start_confl (100) + , learntsize_adjust_inc (1.5) + + // Statistics: (formerly in 'SolverStats') + // + , solves(0), starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0), conflicts_VSIDS(0) + , dec_vars(0), clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0) + , chrono_backtrack(0), non_chrono_backtrack(0) + + , ok (true) + , cla_inc (1) + , var_inc (1) + , watches_bin (WatcherDeleted(ca)) + , watches (WatcherDeleted(ca)) + , qhead (0) + , simpDB_assigns (-1) + , simpDB_props (0) + , order_heap_CHB (VarOrderLt(activity_CHB)) + , order_heap_VSIDS (VarOrderLt(activity_VSIDS)) + , progress_estimate (0) + , remove_satisfied (true) + + , core_lbd_cut (2) + , global_lbd_sum (0) + , lbd_queue (50) + , next_T2_reduce (10000) + , next_L_reduce (15000) + , confl_to_chrono (opt_conf_to_chrono) + , chrono (opt_chrono) + + , counter (0) + + // Resource constraints: + // + , conflict_budget (-1) + , propagation_budget (-1) + , asynch_interrupt (false) + + // simplfiy + , nbSimplifyAll(0) + , s_propagations(0) + + // simplifyAll adjust occasion + , curSimplify(1) + , nbconfbeforesimplify(1000) + , incSimplify(1000) + +{} + + +Solver::~Solver() +{ +} + + +// simplify All +// +CRef Solver::simplePropagate() +{ + CRef confl = CRef_Undef; + int num_props = 0; + watches.cleanAll(); + watches_bin.cleanAll(); + while (qhead < trail.size()) + { + Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate. + vec& ws = watches[p]; + Watcher *i, *j, *end; + num_props++; + + + // First, Propagate binary clauses + vec& wbin = watches_bin[p]; + + for (int k = 0; kblocker; + if (value(blocker) == l_True) + { + *j++ = *i++; continue; + } + + // Make sure the false literal is data[1]: + CRef cr = i->cref; + Clause& c = ca[cr]; + Lit false_lit = ~p; + if (c[0] == false_lit) + c[0] = c[1], c[1] = false_lit; + assert(c[1] == false_lit); + // i++; + + // If 0th watch is true, then clause is already satisfied. + // However, 0th watch is not the blocker, make it blocker using a new watcher w + // why not simply do i->blocker=first in this case? + Lit first = c[0]; + // Watcher w = Watcher(cr, first); + if (first != blocker && value(first) == l_True) + { + i->blocker = first; + *j++ = *i++; continue; + } + + // Look for new watch: + //if (incremental) + //{ // ----------------- INCREMENTAL MODE + // int choosenPos = -1; + // for (int k = 2; k < c.size(); k++) + // { + // if (value(c[k]) != l_False) + // { + // if (decisionLevel()>assumptions.size()) + // { + // choosenPos = k; + // break; + // } + // else + // { + // choosenPos = k; + + // if (value(c[k]) == l_True || !isSelector(var(c[k]))) { + // break; + // } + // } + + // } + // } + // if (choosenPos != -1) + // { + // // watcher i is abandonned using i++, because cr watches now ~c[k] instead of p + // // the blocker is first in the watcher. However, + // // the blocker in the corresponding watcher in ~first is not c[1] + // Watcher w = Watcher(cr, first); i++; + // c[1] = c[choosenPos]; c[choosenPos] = false_lit; + // watches[~c[1]].push(w); + // goto NextClause; + // } + //} + else + { // ----------------- DEFAULT MODE (NOT INCREMENTAL) + for (int k = 2; k < c.size(); k++) + { + + if (value(c[k]) != l_False) + { + // watcher i is abandonned using i++, because cr watches now ~c[k] instead of p + // the blocker is first in the watcher. However, + // the blocker in the corresponding watcher in ~first is not c[1] + Watcher w = Watcher(cr, first); i++; + c[1] = c[k]; c[k] = false_lit; + watches[~c[1]].push(w); + goto NextClause; + } + } + } + + // Did not find watch -- clause is unit under assignment: + i->blocker = first; + *j++ = *i++; + if (value(first) == l_False) + { + confl = cr; + qhead = trail.size(); + // Copy the remaining watches: + while (i < end) + *j++ = *i++; + } + else + { + simpleUncheckEnqueue(first, cr); + } +NextClause:; + } + ws.shrink(i - j); + } + + s_propagations += num_props; + + return confl; +} + +void Solver::simpleUncheckEnqueue(Lit p, CRef from){ + assert(value(p) == l_Undef); + assigns[var(p)] = lbool(!sign(p)); // this makes a lbool object whose value is sign(p) + vardata[var(p)].reason = from; + trail.push_(p); +} + +void Solver::cancelUntilTrailRecord() +{ + for (int c = trail.size() - 1; c >= trailRecord; c--) + { + Var x = var(trail[c]); + assigns[x] = l_Undef; + + } + qhead = trailRecord; + trail.shrink(trail.size() - trailRecord); + +} + +void Solver::litsEnqueue(int cutP, Clause& c) +{ + for (int i = cutP; i < c.size(); i++) + { + simpleUncheckEnqueue(~c[i]); + } +} + +bool Solver::removed(CRef cr) { + return ca[cr].mark() == 1; +} + +void Solver::simpleAnalyze(CRef confl, vec& out_learnt, vec& reason_clause, bool True_confl) +{ + int pathC = 0; + Lit p = lit_Undef; + int index = trail.size() - 1; + + do{ + if (confl != CRef_Undef){ + reason_clause.push(confl); + Clause& c = ca[confl]; + // Special case for binary clauses + // The first one has to be SAT + if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False) { + + assert(value(c[1]) == l_True); + Lit tmp = c[0]; + c[0] = c[1], c[1] = tmp; + } + // if True_confl==true, then choose p begin with the 1th index of c; + for (int j = (p == lit_Undef && True_confl == false) ? 0 : 1; j < c.size(); j++){ + Lit q = c[j]; + if (!seen[var(q)]){ + seen[var(q)] = 1; + pathC++; + } + } + } + else if (confl == CRef_Undef){ + out_learnt.push(~p); + } + // if not break, while() will come to the index of trail blow 0, and fatal error occur; + if (pathC == 0) break; + // Select next clause to look at: + while (!seen[var(trail[index--])]); + // if the reason cr from the 0-level assigned var, we must break avoid move forth further; + // but attention that maybe seen[x]=1 and never be clear. However makes no matter; + if (trailRecord > index + 1) break; + p = trail[index + 1]; + confl = reason(var(p)); + seen[var(p)] = 0; + pathC--; + + } while (pathC >= 0); +} + +void Solver::simplifyLearnt(Clause& c) +{ + //// + original_length_record += c.size(); + + trailRecord = trail.size();// record the start pointer + + vec falseLit; + falseLit.clear(); + + //sort(&c[0], c.size(), VarOrderLevelLt(vardata)); + + bool True_confl = false; + int beforeSize, afterSize; + beforeSize = c.size(); + int i, j; + CRef confl; + + for (i = 0, j = 0; i < c.size(); i++){ + if (value(c[i]) == l_Undef){ + //printf("///@@@ uncheckedEnqueue:index = %d. l_Undef\n", i); + simpleUncheckEnqueue(~c[i]); + c[j++] = c[i]; + confl = simplePropagate(); + if (confl != CRef_Undef){ + break; + } + } + else{ + if (value(c[i]) == l_True){ + //printf("///@@@ uncheckedEnqueue:index = %d. l_True\n", i); + c[j++] = c[i]; + True_confl = true; + confl = reason(var(c[i])); + break; + } + else{ + //printf("///@@@ uncheckedEnqueue:index = %d. l_False\n", i); + falseLit.push(c[i]); + } + } + } + c.shrink(c.size() - j); + afterSize = c.size(); + //printf("\nbefore : %d, after : %d ", beforeSize, afterSize); + + + if (confl != CRef_Undef || True_confl == true){ + simp_learnt_clause.clear(); + simp_reason_clause.clear(); + if (True_confl == true){ + simp_learnt_clause.push(c.last()); + } + simpleAnalyze(confl, simp_learnt_clause, simp_reason_clause, True_confl); + + if (simp_learnt_clause.size() < c.size()){ + for (i = 0; i < simp_learnt_clause.size(); i++){ + c[i] = simp_learnt_clause[i]; + } + c.shrink(c.size() - i); + } + } + + cancelUntilTrailRecord(); + + //// + simplified_length_record += c.size(); + +} + +bool Solver::simplifyLearnt_x(vec& learnts_x) +{ + int beforeSize, afterSize; + int learnts_x_size_before = learnts_x.size(); + + int ci, cj, li, lj; + bool sat, false_lit; + unsigned int nblevels; + //// + //printf("learnts_x size : %d\n", learnts_x.size()); + + //// + int nbSimplified = 0; + int nbSimplifing = 0; + + for (ci = 0, cj = 0; ci < learnts_x.size(); ci++){ + CRef cr = learnts_x[ci]; + Clause& c = ca[cr]; + + if (removed(cr)) continue; + else if (c.simplified()){ + learnts_x[cj++] = learnts_x[ci]; + //// + nbSimplified++; + } + else{ + //// + nbSimplifing++; + sat = false_lit = false; + for (int i = 0; i < c.size(); i++){ + if (value(c[i]) == l_True){ + sat = true; + break; + } + else if (value(c[i]) == l_False){ + false_lit = true; + } + } + if (sat){ + removeClause(cr); + } + else{ + detachClause(cr, true); + + if (false_lit){ + for (li = lj = 0; li < c.size(); li++){ + if (value(c[li]) != l_False){ + c[lj++] = c[li]; + } + } + c.shrink(li - lj); + } + + beforeSize = c.size(); + assert(c.size() > 1); + // simplify a learnt clause c + simplifyLearnt(c); + assert(c.size() > 0); + afterSize = c.size(); + + //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize); + + if (c.size() == 1){ + // when unit clause occur, enqueue and propagate + uncheckedEnqueue(c[0]); + if (propagate() != CRef_Undef){ + ok = false; + return false; + } + // delete the clause memory in logic + c.mark(1); + ca.free(cr); + } + else{ + attachClause(cr); + learnts_x[cj++] = learnts_x[ci]; + + nblevels = computeLBD(c); + if (nblevels < c.lbd()){ + //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels); + c.set_lbd(nblevels); + } + if (c.mark() != CORE){ + if (c.lbd() <= core_lbd_cut){ + //if (c.mark() == LOCAL) local_learnts_dirty = true; + //else tier2_learnts_dirty = true; + cj--; + learnts_core.push(cr); + c.mark(CORE); + } + else if (c.mark() == LOCAL && c.lbd() <= 6){ + //local_learnts_dirty = true; + cj--; + learnts_tier2.push(cr); + c.mark(TIER2); + } + } + + c.setSimplified(true); + } + } + } + } + learnts_x.shrink(ci - cj); + + // printf("c nbLearnts_x %d / %d, nbSimplified: %d, nbSimplifing: %d\n", + // learnts_x_size_before, learnts_x.size(), nbSimplified, nbSimplifing); + + return true; +} + +bool Solver::simplifyLearnt_core() +{ + int beforeSize, afterSize; + int learnts_core_size_before = learnts_core.size(); + + int ci, cj, li, lj; + bool sat, false_lit; + unsigned int nblevels; + //// + //printf("learnts_x size : %d\n", learnts_x.size()); + + //// + int nbSimplified = 0; + int nbSimplifing = 0; + + for (ci = 0, cj = 0; ci < learnts_core.size(); ci++){ + CRef cr = learnts_core[ci]; + Clause& c = ca[cr]; + + if (removed(cr)) continue; + else if (c.simplified()){ + learnts_core[cj++] = learnts_core[ci]; + //// + nbSimplified++; + } + else{ + int saved_size=c.size(); + // if (drup_file){ + // add_oc.clear(); + // for (int i = 0; i < c.size(); i++) add_oc.push(c[i]); } + //// + nbSimplifing++; + sat = false_lit = false; + for (int i = 0; i < c.size(); i++){ + if (value(c[i]) == l_True){ + sat = true; + break; + } + else if (value(c[i]) == l_False){ + false_lit = true; + } + } + if (sat){ + removeClause(cr); + } + else{ + detachClause(cr, true); + + if (false_lit){ + for (li = lj = 0; li < c.size(); li++){ + if (value(c[li]) != l_False){ + c[lj++] = c[li]; + } + } + c.shrink(li - lj); + } + + beforeSize = c.size(); + assert(c.size() > 1); + // simplify a learnt clause c + simplifyLearnt(c); + assert(c.size() > 0); + afterSize = c.size(); + + if(drup_file && saved_size !=c.size()){ +#ifdef BIN_DRUP + binDRUP('a', c , drup_file); + // binDRUP('d', add_oc, drup_file); +#else + for (int i = 0; i < c.size(); i++) + fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); + fprintf(drup_file, "0\n"); + + // fprintf(drup_file, "d "); + // for (int i = 0; i < add_oc.size(); i++) + // fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1)); + // fprintf(drup_file, "0\n"); +#endif + } + + //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize); + + if (c.size() == 1){ + // when unit clause occur, enqueue and propagate + uncheckedEnqueue(c[0]); + if (propagate() != CRef_Undef){ + ok = false; + return false; + } + // delete the clause memory in logic + c.mark(1); + ca.free(cr); +//#ifdef BIN_DRUP +// binDRUP('d', c, drup_file); +//#else +// fprintf(drup_file, "d "); +// for (int i = 0; i < c.size(); i++) +// fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); +// fprintf(drup_file, "0\n"); +//#endif + } + else{ + attachClause(cr); + learnts_core[cj++] = learnts_core[ci]; + + nblevels = computeLBD(c); + if (nblevels < c.lbd()){ + //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels); + c.set_lbd(nblevels); + } + + c.setSimplified(true); + } + } + } + } + learnts_core.shrink(ci - cj); + + // printf("c nbLearnts_core %d / %d, nbSimplified: %d, nbSimplifing: %d\n", + // learnts_core_size_before, learnts_core.size(), nbSimplified, nbSimplifing); + + return true; + +} + + +int Solver::is_duplicate(std::vector&c){ + auto time_point_0 = std::chrono::high_resolution_clock::now(); + dupl_db_size++; + int res = 0; + + int sz = c.size(); + std::vector tmp(c); + sort(tmp.begin(),tmp.end()); + + uint64_t hash = 0; + + for (int i =0; i> 2); + } + + int32_t head = tmp[0]; + auto it0 = ht.find(head); + if (it0 != ht.end()){ + auto it1=ht[head].find(sz); + if (it1 != ht[head].end()){ + auto it2 = ht[head][sz].find(hash); + if (it2 != ht[head][sz].end()){ + it2->second++; + res = it2->second; + } + else{ + ht[head][sz][hash]=1; + } + } + else{ + ht[head][sz][hash]=1; + } + }else{ + ht[head][sz][hash]=1; + } + auto time_point_1 = std::chrono::high_resolution_clock::now(); + duptime += std::chrono::duration_cast(time_point_1-time_point_0); + return res; +} + +bool Solver::simplifyLearnt_tier2() +{ + int beforeSize, afterSize; + int learnts_tier2_size_before = learnts_tier2.size(); + + int ci, cj, li, lj; + bool sat, false_lit; + unsigned int nblevels; + //// + //printf("learnts_x size : %d\n", learnts_x.size()); + + //// + int nbSimplified = 0; + int nbSimplifing = 0; + + for (ci = 0, cj = 0; ci < learnts_tier2.size(); ci++){ + CRef cr = learnts_tier2[ci]; + Clause& c = ca[cr]; + + if (removed(cr)) continue; + else if (c.simplified()){ + learnts_tier2[cj++] = learnts_tier2[ci]; + //// + nbSimplified++; + } + else{ + int saved_size=c.size(); + // if (drup_file){ + // add_oc.clear(); + // for (int i = 0; i < c.size(); i++) add_oc.push(c[i]); } + //// + nbSimplifing++; + sat = false_lit = false; + for (int i = 0; i < c.size(); i++){ + if (value(c[i]) == l_True){ + sat = true; + break; + } + else if (value(c[i]) == l_False){ + false_lit = true; + } + } + if (sat){ + removeClause(cr); + } + else{ + detachClause(cr, true); + + if (false_lit){ + for (li = lj = 0; li < c.size(); li++){ + if (value(c[li]) != l_False){ + c[lj++] = c[li]; + } + } + c.shrink(li - lj); + } + + beforeSize = c.size(); + assert(c.size() > 1); + // simplify a learnt clause c + simplifyLearnt(c); + assert(c.size() > 0); + afterSize = c.size(); + + if(drup_file && saved_size!=c.size()){ + +#ifdef BIN_DRUP + binDRUP('a', c , drup_file); + // binDRUP('d', add_oc, drup_file); +#else + for (int i = 0; i < c.size(); i++) + fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); + fprintf(drup_file, "0\n"); + + // fprintf(drup_file, "d "); + // for (int i = 0; i < add_oc.size(); i++) + // fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1)); + // fprintf(drup_file, "0\n"); +#endif + } + + //printf("beforeSize: %2d, afterSize: %2d\n", beforeSize, afterSize); + + if (c.size() == 1){ + // when unit clause occur, enqueue and propagate + uncheckedEnqueue(c[0]); + if (propagate() != CRef_Undef){ + ok = false; + return false; + } + // delete the clause memory in logic + c.mark(1); + ca.free(cr); +//#ifdef BIN_DRUP +// binDRUP('d', c, drup_file); +//#else +// fprintf(drup_file, "d "); +// for (int i = 0; i < c.size(); i++) +// fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); +// fprintf(drup_file, "0\n"); +//#endif + } + else{ + + + nblevels = computeLBD(c); + if (nblevels < c.lbd()){ + //printf("lbd-before: %d, lbd-after: %d\n", c.lbd(), nblevels); + c.set_lbd(nblevels); + } + //duplicate learnts + int id = 0; + + std::vector tmp; + for (int i = 0; i < c.size(); i++) + tmp.push_back(c[i].x); + id = is_duplicate(tmp); + + + //duplicate learnts + + if (id < min_number_of_learnts_copies+2){ + attachClause(cr); + learnts_tier2[cj++] = learnts_tier2[ci]; + if (id == min_number_of_learnts_copies+1){ + duplicates_added_minimization++; + } + if ((c.lbd() <= core_lbd_cut)||(id == min_number_of_learnts_copies+1)){ + //if (id == min_number_of_learnts_copies+1){ + cj--; + learnts_core.push(cr); + c.mark(CORE); + } + + c.setSimplified(true); + } + } + } + } + } + learnts_tier2.shrink(ci - cj); + + // printf("c nbLearnts_tier2 %d / %d, nbSimplified: %d, nbSimplifing: %d\n", + // learnts_tier2_size_before, learnts_tier2.size(), nbSimplified, nbSimplifing); + + return true; + +} + +bool Solver::simplifyAll() +{ + //// + simplified_length_record = original_length_record = 0; + + if (!ok || propagate() != CRef_Undef) + return ok = false; + + //// cleanLearnts(also can delete these code), here just for analyzing + //if (local_learnts_dirty) cleanLearnts(learnts_local, LOCAL); + //if (tier2_learnts_dirty) cleanLearnts(learnts_tier2, TIER2); + //local_learnts_dirty = tier2_learnts_dirty = false; + + if (!simplifyLearnt_core()) return ok = false; + if (!simplifyLearnt_tier2()) return ok = false; + //if (!simplifyLearnt_x(learnts_local)) return ok = false; + + checkGarbage(); + + //// + // printf("c size_reduce_ratio : %4.2f%%\n", + // original_length_record == 0 ? 0 : (original_length_record - simplified_length_record) * 100 / (double)original_length_record); + + return true; +} +//================================================================================================= +// Minor methods: + + +// Creates a new SAT variable in the solver. If 'decision' is cleared, variable will not be +// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result). +// + +Var Solver::newVar(bool sign, bool dvar) +{ + int v = nVars(); + // printf("%d %d %d\n", v, sign, dvar); + watches_bin.init(mkLit(v, false)); + watches_bin.init(mkLit(v, true )); + watches .init(mkLit(v, false)); + watches .init(mkLit(v, true )); + assigns .push(l_Undef); + vardata .push(mkVarData(CRef_Undef, 0)); + activity_CHB .push(0); + activity_VSIDS.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0); + + picked.push(0); + conflicted.push(0); + almost_conflicted.push(0); +#ifdef ANTI_EXPLORATION + canceled.push(0); +#endif + seen .push(0); + seen2 .push(0); + polarity .push(sign); + decision .push(); + trail .capacity(v+1); + setDecisionVar(v, dvar); + + return v; +} + + +bool Solver::addClause_(vec& ps) +{ + assert(decisionLevel() == 0); + if (!ok) return false; + + // Check if clause is satisfied and remove false/duplicate literals: + sort(ps); + Lit p; int i, j; + + if (drup_file){ + add_oc.clear(); + for (int i = 0; i < ps.size(); i++) add_oc.push(ps[i]); } + + for (i = j = 0, p = lit_Undef; i < ps.size(); i++) + if (value(ps[i]) == l_True || ps[i] == ~p) + return true; + else if (value(ps[i]) != l_False && ps[i] != p) + ps[j++] = p = ps[i]; + ps.shrink(i - j); + + if (drup_file && i != j){ +#ifdef BIN_DRUP + binDRUP('a', ps, drup_file); + binDRUP('d', add_oc, drup_file); +#else + for (int i = 0; i < ps.size(); i++) + fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1)); + fprintf(drup_file, "0\n"); + + fprintf(drup_file, "d "); + for (int i = 0; i < add_oc.size(); i++) + fprintf(drup_file, "%i ", (var(add_oc[i]) + 1) * (-2 * sign(add_oc[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + } + + if (ps.size() == 0) + return ok = false; + else if (ps.size() == 1){ + uncheckedEnqueue(ps[0]); + return ok = (propagate() == CRef_Undef); + }else{ + CRef cr = ca.alloc(ps, false); + clauses.push(cr); + attachClause(cr); + } + + return true; +} + +bool Solver::importClauses() { + assert(decisionLevel() == 0); + + if (cbkImportClause == NULL) + return true; + int lbd, k, l; + bool alreadySat; + while (cbkImportClause(issuer, &lbd, importedClause)) { + // fflush(stdout); + alreadySat = false; + // Simplify clause before add + for (k = l = 0; k < importedClause.size(); k++) { + if (value(importedClause[k]) == l_True) { + alreadySat = true; + break; + } else if (value(importedClause[k]) == l_Undef) { + importedClause[l++] = importedClause[k]; + } + } + importedClause.shrink(k - l); + + if (alreadySat) { + importedClause.clear(); + continue; + } + + if (importedClause.size() == 0) { + return false; + } else if (importedClause.size() == 1) { + uncheckedEnqueue(importedClause[0]); + } else { + CRef cr = ca.alloc(importedClause, true); + lbd = importedClause.size(); + ca[cr].set_lbd(lbd); + if (lbd <= core_lbd_cut) { + learnts_core.push(cr); + ca[cr].mark(CORE); + } else if (lbd <= 6) { + learnts_tier2.push(cr); + ca[cr].mark(TIER2); + ca[cr].touched() = conflicts; + } else { + learnts_local.push(cr); + claBumpActivity(ca[cr]); + } + attachClause(cr); + } + importedClause.clear(); + } + + return true; +} + +void Solver::attachClause(CRef cr) { + const Clause& c = ca[cr]; + assert(c.size() > 1); + OccLists, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches; + ws[~c[0]].push(Watcher(cr, c[1])); + ws[~c[1]].push(Watcher(cr, c[0])); + if (c.learnt()) learnts_literals += c.size(); + else clauses_literals += c.size(); } + + +void Solver::detachClause(CRef cr, bool strict) { + const Clause& c = ca[cr]; + assert(c.size() > 1); + OccLists, WatcherDeleted>& ws = c.size() == 2 ? watches_bin : watches; + + if (strict){ + remove(ws[~c[0]], Watcher(cr, c[1])); + remove(ws[~c[1]], Watcher(cr, c[0])); + }else{ + // Lazy detaching: (NOTE! Must clean all watcher lists before garbage collecting this clause) + ws.smudge(~c[0]); + ws.smudge(~c[1]); + } + + if (c.learnt()) learnts_literals -= c.size(); + else clauses_literals -= c.size(); } + + +void Solver::removeClause(CRef cr) { + Clause& c = ca[cr]; + + if (drup_file){ + if (c.mark() != 1){ +#ifdef BIN_DRUP + binDRUP('d', c, drup_file); +#else + fprintf(drup_file, "d "); + for (int i = 0; i < c.size(); i++) + fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + }else + printf("c Bug. I don't expect this to happen.\n"); + } + + detachClause(cr); + // Don't leave pointers to free'd memory! + if (locked(c)){ + Lit implied = c.size() != 2 ? c[0] : (value(c[0]) == l_True ? c[0] : c[1]); + vardata[var(implied)].reason = CRef_Undef; } + c.mark(1); + ca.free(cr); +} + + +bool Solver::satisfied(const Clause& c) const { + for (int i = 0; i < c.size(); i++) + if (value(c[i]) == l_True) + return true; + return false; } + + +// Revert to the state at given level (keeping all assignment at 'level' but not beyond). +// +void Solver::cancelUntil(int bLevel) { + + if (decisionLevel() > bLevel){ +#ifdef PRINT_OUT + std::cout << "bt " << bLevel << "\n"; +#endif + add_tmp.clear(); + for (int c = trail.size()-1; c >= trail_lim[bLevel]; c--) + { + Var x = var(trail[c]); + + if (level(x) <= bLevel) + { + add_tmp.push(trail[c]); + } + else + { + if (!VSIDS){ + uint32_t age = conflicts - picked[x]; + if (age > 0){ + double adjusted_reward = ((double) (conflicted[x] + almost_conflicted[x])) / ((double) age); + double old_activity = activity_CHB[x]; + activity_CHB[x] = step_size * adjusted_reward + ((1 - step_size) * old_activity); + if (order_heap_CHB.inHeap(x)){ + if (activity_CHB[x] > old_activity) + order_heap_CHB.decrease(x); + else + order_heap_CHB.increase(x); + } + } +#ifdef ANTI_EXPLORATION + canceled[x] = conflicts; +#endif + } + + assigns [x] = l_Undef; +#ifdef PRINT_OUT + std::cout << "undo " << x << "\n"; +#endif + if (phase_saving > 1 || (phase_saving == 1) && c > trail_lim.last()){ + polarity[x] = sign(trail[c]); + } + insertVarOrder(x); + } + } + qhead = trail_lim[bLevel]; + trail.shrink(trail.size() - trail_lim[bLevel]); + trail_lim.shrink(trail_lim.size() - bLevel); + for (int nLitId = add_tmp.size() - 1; nLitId >= 0; --nLitId) + { + trail.push_(add_tmp[nLitId]); + } + + add_tmp.clear(); + } } + + +//================================================================================================= +// Major methods: + + +Lit Solver::pickBranchLit() +{ + Var next = var_Undef; + // Heap& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB; + Heap& order_heap = ((!VSIDS)? order_heap_CHB:order_heap_VSIDS); + + // Random decision: + /*if (drand(random_seed) < random_var_freq && !order_heap.empty()){ + next = order_heap[irand(random_seed,order_heap.size())]; + if (value(next) == l_Undef && decision[next]) + rnd_decisions++; }*/ + + // Activity based decision: + while (next == var_Undef || value(next) != l_Undef || !decision[next]) + if (order_heap.empty()) + return lit_Undef; + else{ +#ifdef ANTI_EXPLORATION + if (!VSIDS){ + Var v = order_heap_CHB[0]; + uint32_t age = conflicts - canceled[v]; + while (age > 0){ + double decay = pow(0.95, age); + activity_CHB[v] *= decay; + if (order_heap_CHB.inHeap(v)) + order_heap_CHB.increase(v); + canceled[v] = conflicts; + v = order_heap_CHB[0]; + age = conflicts - canceled[v]; + } + } +#endif + next = order_heap.removeMin(); + } + + return mkLit(next, polarity[next]); + + +} + +inline Solver::ConflictData Solver::FindConflictLevel(CRef cind) +{ + ConflictData data; + Clause& conflCls = ca[cind]; + data.nHighestLevel = level(var(conflCls[0])); + if (data.nHighestLevel == decisionLevel() && level(var(conflCls[1])) == decisionLevel()) + { + return data; + } + + int highestId = 0; + data.bOnlyOneLitFromHighest = true; + // find the largest decision level in the clause + for (int nLitId = 1; nLitId < conflCls.size(); ++nLitId) + { + int nLevel = level(var(conflCls[nLitId])); + if (nLevel > data.nHighestLevel) + { + highestId = nLitId; + data.nHighestLevel = nLevel; + data.bOnlyOneLitFromHighest = true; + } + else if (nLevel == data.nHighestLevel && data.bOnlyOneLitFromHighest == true) + { + data.bOnlyOneLitFromHighest = false; + } + } + + if (highestId != 0) + { + std::swap(conflCls[0], conflCls[highestId]); + if (highestId > 1) + { + OccLists, WatcherDeleted>& ws = conflCls.size() == 2 ? watches_bin : watches; + //ws.smudge(~conflCls[highestId]); + remove(ws[~conflCls[highestId]], Watcher(cind, conflCls[1])); + ws[~conflCls[0]].push(Watcher(cind, conflCls[1])); + } + } + + return data; +} + + +/*_________________________________________________________________________________________________ +| +| analyze : (confl : Clause*) (out_learnt : vec&) (out_btlevel : int&) -> [void] +| +| Description: +| Analyze conflict and produce a reason clause. +| +| Pre-conditions: +| * 'out_learnt' is assumed to be cleared. +| * Current decision level must be greater than root level. +| +| Post-conditions: +| * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'. +| * If out_learnt.size() > 1 then 'out_learnt[1]' has the greatest decision level of the +| rest of literals. There may be others from the same level though. +| +|________________________________________________________________________________________________@*/ +void Solver::analyze(CRef confl, vec& out_learnt, int& out_btlevel, int& out_lbd) +{ + int pathC = 0; + Lit p = lit_Undef; + + // Generate conflict clause: + // + out_learnt.push(); // (leave room for the asserting literal) + int index = trail.size() - 1; + int nDecisionLevel = level(var(ca[confl][0])); + assert(nDecisionLevel == level(var(ca[confl][0]))); + + do{ + assert(confl != CRef_Undef); // (otherwise should be UIP) + Clause& c = ca[confl]; + + // For binary clauses, we don't rearrange literals in propagate(), so check and make sure the first is an implied lit. + if (p != lit_Undef && c.size() == 2 && value(c[0]) == l_False){ + assert(value(c[1]) == l_True); + Lit tmp = c[0]; + c[0] = c[1], c[1] = tmp; } + + // Update LBD if improved. + if (c.learnt() && c.mark() != CORE){ + int lbd = computeLBD(c); + if (lbd < c.lbd()){ + if (c.lbd() <= 30) c.removable(false); // Protect once from reduction. + c.set_lbd(lbd); + if (lbd <= core_lbd_cut){ + learnts_core.push(confl); + c.mark(CORE); + }else if (lbd <= 6 && c.mark() == LOCAL){ + // Bug: 'cr' may already be in 'learnts_tier2', e.g., if 'cr' was demoted from TIER2 + // to LOCAL previously and if that 'cr' is not cleaned from 'learnts_tier2' yet. + learnts_tier2.push(confl); + c.mark(TIER2); } + } + + if (c.mark() == TIER2) + c.touched() = conflicts; + else if (c.mark() == LOCAL) + claBumpActivity(c); + } + + for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){ + Lit q = c[j]; + + if (!seen[var(q)] && level(var(q)) > 0){ + if (VSIDS){ + varBumpActivity(var(q), .5); + add_tmp.push(q); + }else + conflicted[var(q)]++; + seen[var(q)] = 1; + if (level(var(q)) >= nDecisionLevel){ + pathC++; + }else + out_learnt.push(q); + } + } + + // Select next clause to look at: + do { + while (!seen[var(trail[index--])]); + p = trail[index+1]; + } while (level(var(p)) < nDecisionLevel); + + confl = reason(var(p)); + seen[var(p)] = 0; + pathC--; + + }while (pathC > 0); + out_learnt[0] = ~p; + + // Simplify conflict clause: + // + int i, j; + out_learnt.copyTo(analyze_toclear); + if (ccmin_mode == 2){ + uint32_t abstract_level = 0; + for (i = 1; i < out_learnt.size(); i++) + abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict) + + for (i = j = 1; i < out_learnt.size(); i++) + if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level)) + out_learnt[j++] = out_learnt[i]; + + }else if (ccmin_mode == 1){ + for (i = j = 1; i < out_learnt.size(); i++){ + Var x = var(out_learnt[i]); + + if (reason(x) == CRef_Undef) + out_learnt[j++] = out_learnt[i]; + else{ + Clause& c = ca[reason(var(out_learnt[i]))]; + for (int k = c.size() == 2 ? 0 : 1; k < c.size(); k++) + if (!seen[var(c[k])] && level(var(c[k])) > 0){ + out_learnt[j++] = out_learnt[i]; + break; } + } + } + }else + i = j = out_learnt.size(); + + max_literals += out_learnt.size(); + out_learnt.shrink(i - j); + tot_literals += out_learnt.size(); + + out_lbd = computeLBD(out_learnt); + if (out_lbd <= 6 && out_learnt.size() <= 30) // Try further minimization? + if (binResMinimize(out_learnt)) + out_lbd = computeLBD(out_learnt); // Recompute LBD if minimized. + + // Find correct backtrack level: + // + if (out_learnt.size() == 1) + out_btlevel = 0; + else{ + int max_i = 1; + // Find the first literal assigned at the next-highest level: + for (int i = 2; i < out_learnt.size(); i++) + if (level(var(out_learnt[i])) > level(var(out_learnt[max_i]))) + max_i = i; + // Swap-in this literal at index 1: + Lit p = out_learnt[max_i]; + out_learnt[max_i] = out_learnt[1]; + out_learnt[1] = p; + out_btlevel = level(var(p)); + } + + if (VSIDS){ + for (int i = 0; i < add_tmp.size(); i++){ + Var v = var(add_tmp[i]); + if (level(v) >= out_btlevel - 1) + varBumpActivity(v, 1); + } + add_tmp.clear(); + }else{ + seen[var(p)] = true; + for(int i = out_learnt.size() - 1; i >= 0; i--){ + Var v = var(out_learnt[i]); + CRef rea = reason(v); + if (rea != CRef_Undef){ + const Clause& reaC = ca[rea]; + for (int i = 0; i < reaC.size(); i++){ + Lit l = reaC[i]; + if (!seen[var(l)]){ + seen[var(l)] = true; + almost_conflicted[var(l)]++; + analyze_toclear.push(l); } } } } } + + for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0; // ('seen[]' is now cleared) +} + + +// Try further learnt clause minimization by means of binary clause resolution. +bool Solver::binResMinimize(vec& out_learnt) +{ + // Preparation: remember which false variables we have in 'out_learnt'. + counter++; + for (int i = 1; i < out_learnt.size(); i++) + seen2[var(out_learnt[i])] = counter; + + // Get the list of binary clauses containing 'out_learnt[0]'. + const vec& ws = watches_bin[~out_learnt[0]]; + + int to_remove = 0; + for (int i = 0; i < ws.size(); i++){ + Lit the_other = ws[i].blocker; + // Does 'the_other' appear negatively in 'out_learnt'? + if (seen2[var(the_other)] == counter && value(the_other) == l_True){ + to_remove++; + seen2[var(the_other)] = counter - 1; // Remember to remove this variable. + } + } + + // Shrink. + if (to_remove > 0){ + int last = out_learnt.size() - 1; + for (int i = 1; i < out_learnt.size() - to_remove; i++) + if (seen2[var(out_learnt[i])] != counter) + out_learnt[i--] = out_learnt[last--]; + out_learnt.shrink(to_remove); + } + return to_remove != 0; +} + + +// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is +// visiting literals at levels that cannot be removed later. +bool Solver::litRedundant(Lit p, uint32_t abstract_levels) +{ + analyze_stack.clear(); analyze_stack.push(p); + int top = analyze_toclear.size(); + while (analyze_stack.size() > 0){ + assert(reason(var(analyze_stack.last())) != CRef_Undef); + Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop(); + + // Special handling for binary clauses like in 'analyze()'. + if (c.size() == 2 && value(c[0]) == l_False){ + assert(value(c[1]) == l_True); + Lit tmp = c[0]; + c[0] = c[1], c[1] = tmp; } + + for (int i = 1; i < c.size(); i++){ + Lit p = c[i]; + if (!seen[var(p)] && level(var(p)) > 0){ + if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){ + seen[var(p)] = 1; + analyze_stack.push(p); + analyze_toclear.push(p); + }else{ + for (int j = top; j < analyze_toclear.size(); j++) + seen[var(analyze_toclear[j])] = 0; + analyze_toclear.shrink(analyze_toclear.size() - top); + return false; + } + } + } + } + + return true; +} + + +/*_________________________________________________________________________________________________ +| +| analyzeFinal : (p : Lit) -> [void] +| +| Description: +| Specialized analysis procedure to express the final conflict in terms of assumptions. +| Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and +| stores the result in 'out_conflict'. +|________________________________________________________________________________________________@*/ +void Solver::analyzeFinal(Lit p, vec& out_conflict) +{ + out_conflict.clear(); + out_conflict.push(p); + + if (decisionLevel() == 0) + return; + + seen[var(p)] = 1; + + for (int i = trail.size()-1; i >= trail_lim[0]; i--){ + Var x = var(trail[i]); + if (seen[x]){ + if (reason(x) == CRef_Undef){ + assert(level(x) > 0); + out_conflict.push(~trail[i]); + }else{ + Clause& c = ca[reason(x)]; + for (int j = c.size() == 2 ? 0 : 1; j < c.size(); j++) + if (level(var(c[j])) > 0) + seen[var(c[j])] = 1; + } + seen[x] = 0; + } + } + + seen[var(p)] = 0; +} + + +void Solver::uncheckedEnqueue(Lit p, int level, CRef from) +{ + assert(value(p) == l_Undef); + Var x = var(p); + if (!VSIDS){ + picked[x] = conflicts; + conflicted[x] = 0; + almost_conflicted[x] = 0; +#ifdef ANTI_EXPLORATION + uint32_t age = conflicts - canceled[var(p)]; + if (age > 0){ + double decay = pow(0.95, age); + activity_CHB[var(p)] *= decay; + if (order_heap_CHB.inHeap(var(p))) + order_heap_CHB.increase(var(p)); + } +#endif + } + + assigns[x] = lbool(!sign(p)); + vardata[x] = mkVarData(from, level); + trail.push_(p); +} + + +/*_________________________________________________________________________________________________ +| +| propagate : [void] -> [Clause*] +| +| Description: +| Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned, +| otherwise CRef_Undef. +| +| Post-conditions: +| * the propagation queue is empty, even if there was a conflict. +|________________________________________________________________________________________________@*/ +CRef Solver::propagate() +{ + CRef confl = CRef_Undef; + int num_props = 0; + watches.cleanAll(); + watches_bin.cleanAll(); + + while (qhead < trail.size()){ + Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate. + int currLevel = level(var(p)); + vec& ws = watches[p]; + Watcher *i, *j, *end; + num_props++; + + vec& ws_bin = watches_bin[p]; // Propagate binary clauses first. + for (int k = 0; k < ws_bin.size(); k++){ + Lit the_other = ws_bin[k].blocker; + if (value(the_other) == l_False){ + confl = ws_bin[k].cref; +#ifdef LOOSE_PROP_STAT + return confl; +#else + goto ExitProp; +#endif + }else if(value(the_other) == l_Undef) + { + uncheckedEnqueue(the_other, currLevel, ws_bin[k].cref); +#ifdef PRINT_OUT + std::cout << "i " << the_other << " l " << currLevel << "\n"; +#endif + } + } + + for (i = j = (Watcher*)ws, end = i + ws.size(); i != end;){ + // Try to avoid inspecting the clause: + Lit blocker = i->blocker; + if (value(blocker) == l_True){ + *j++ = *i++; continue; } + + // Make sure the false literal is data[1]: + CRef cr = i->cref; + Clause& c = ca[cr]; + Lit false_lit = ~p; + if (c[0] == false_lit) + c[0] = c[1], c[1] = false_lit; + assert(c[1] == false_lit); + i++; + + // If 0th watch is true, then clause is already satisfied. + Lit first = c[0]; + Watcher w = Watcher(cr, first); + if (first != blocker && value(first) == l_True){ + *j++ = w; continue; } + + // Look for new watch: + for (int k = 2; k < c.size(); k++) + if (value(c[k]) != l_False){ + c[1] = c[k]; c[k] = false_lit; + watches[~c[1]].push(w); + goto NextClause; } + + // Did not find watch -- clause is unit under assignment: + *j++ = w; + if (value(first) == l_False){ + confl = cr; + qhead = trail.size(); + // Copy the remaining watches: + while (i < end) + *j++ = *i++; + }else + { + if (currLevel == decisionLevel()) + { + uncheckedEnqueue(first, currLevel, cr); +#ifdef PRINT_OUT + std::cout << "i " << first << " l " << currLevel << "\n"; +#endif + } + else + { + int nMaxLevel = currLevel; + int nMaxInd = 1; + // pass over all the literals in the clause and find the one with the biggest level + for (int nInd = 2; nInd < c.size(); ++nInd) + { + int nLevel = level(var(c[nInd])); + if (nLevel > nMaxLevel) + { + nMaxLevel = nLevel; + nMaxInd = nInd; + } + } + + if (nMaxInd != 1) + { + std::swap(c[1], c[nMaxInd]); + *j--; // undo last watch + watches[~c[1]].push(w); + } + + uncheckedEnqueue(first, nMaxLevel, cr); +#ifdef PRINT_OUT + std::cout << "i " << first << " l " << nMaxLevel << "\n"; +#endif + } + } + +NextClause:; + } + ws.shrink(i - j); + } + +ExitProp:; + propagations += num_props; + simpDB_props -= num_props; + + return confl; +} + + +/*_________________________________________________________________________________________________ +| +| reduceDB : () -> [void] +| +| Description: +| Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked +| clauses are clauses that are reason to some assignment. Binary clauses are never removed. +|________________________________________________________________________________________________@*/ +struct reduceDB_lt { + ClauseAllocator& ca; + reduceDB_lt(ClauseAllocator& ca_) : ca(ca_) {} + bool operator () (CRef x, CRef y) const { return ca[x].activity() < ca[y].activity(); } +}; +void Solver::reduceDB() +{ + int i, j; + //if (local_learnts_dirty) cleanLearnts(learnts_local, LOCAL); + //local_learnts_dirty = false; + + sort(learnts_local, reduceDB_lt(ca)); + + int limit = learnts_local.size() / 2; + for (i = j = 0; i < learnts_local.size(); i++){ + Clause& c = ca[learnts_local[i]]; + if (c.mark() == LOCAL) + if (c.removable() && !locked(c) && i < limit) + removeClause(learnts_local[i]); + else{ + if (!c.removable()) limit++; + c.removable(true); + learnts_local[j++] = learnts_local[i]; } + } + learnts_local.shrink(i - j); + + checkGarbage(); +} +void Solver::reduceDB_Tier2() +{ + int i, j; + for (i = j = 0; i < learnts_tier2.size(); i++){ + Clause& c = ca[learnts_tier2[i]]; + if (c.mark() == TIER2) + if (!locked(c) && c.touched() + 30000 < conflicts){ + learnts_local.push(learnts_tier2[i]); + c.mark(LOCAL); + //c.removable(true); + c.activity() = 0; + claBumpActivity(c); + }else + learnts_tier2[j++] = learnts_tier2[i]; + } + learnts_tier2.shrink(i - j); +} + + +void Solver::removeSatisfied(vec& cs) +{ + int i, j; + for (i = j = 0; i < cs.size(); i++){ + Clause& c = ca[cs[i]]; + if (satisfied(c)) + removeClause(cs[i]); + else + cs[j++] = cs[i]; + } + cs.shrink(i - j); +} + +void Solver::safeRemoveSatisfied(vec& cs, unsigned valid_mark) +{ + int i, j; + for (i = j = 0; i < cs.size(); i++){ + Clause& c = ca[cs[i]]; + if (c.mark() == valid_mark) + if (satisfied(c)) + removeClause(cs[i]); + else + cs[j++] = cs[i]; + } + cs.shrink(i - j); +} + +void Solver::rebuildOrderHeap() +{ + vec vs; + for (Var v = 0; v < nVars(); v++) + if (decision[v] && value(v) == l_Undef) + vs.push(v); + + order_heap_CHB .build(vs); + order_heap_VSIDS.build(vs); +} + + +/*_________________________________________________________________________________________________ +| +| simplify : [void] -> [bool] +| +| Description: +| Simplify the clause database according to the current top-level assigment. Currently, the only +| thing done here is the removal of satisfied clauses, but more things can be put here. +|________________________________________________________________________________________________@*/ +bool Solver::simplify() +{ + assert(decisionLevel() == 0); + + if (!ok || propagate() != CRef_Undef) + return ok = false; + + if (nAssigns() == simpDB_assigns || (simpDB_props > 0)) + return true; + + // Remove satisfied clauses: + removeSatisfied(learnts_core); // Should clean core first. + safeRemoveSatisfied(learnts_tier2, TIER2); + safeRemoveSatisfied(learnts_local, LOCAL); + if (remove_satisfied) // Can be turned off. + removeSatisfied(clauses); + checkGarbage(); + rebuildOrderHeap(); + + simpDB_assigns = nAssigns(); + simpDB_props = clauses_literals + learnts_literals; // (shouldn't depend on stats really, but it will do for now) + + return true; +} + +/*_________________________________________________________________________________________________ +| +| search : (nof_conflicts : int) (params : const SearchParams&) -> [lbool] +| +| Description: +| Search for a model the specified number of conflicts. +| +| Output: +| 'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If +| all variables are decision variables, this means that the clause set is satisfiable. 'l_False' +| if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached. +|________________________________________________________________________________________________@*/ + +void Solver::info_based_rephase(){ + int var_nums = nVars(); + for(int i=0;iin_conflict_sz;++i){ + int v = lssolver->in_conflict[i]; + if(VSIDS){ + varBumpActivity(v-1,lssolver->conflict_ct[v]); + }else{ + conflicted[v-1] += lssolver->conflict_ct[v]; + } + } + + + +} + +void Solver::rand_based_rephase(){ + int var_nums = nVars(); + int pick_rand = rand()%1000; + + //local search + if ((pick_rand-=100)<0){ + for(int i=0;i learnt_clause; + bool cached = false; + starts++; + + freeze_ls_restart_num--; + bool can_call_ls = true; + + if(freeze_ls_restart_num<1){ + + bool res = call_ls(top_trail_UP); + + if(res){ + solved_by_ls = true; + return l_True; + } + + } + + // if(ls_call_num>1){ + if(rand()%100<50) info_based_rephase(); + else rand_based_rephase(); + // } + + + + // simplify + // + if (conflicts >= curSimplify * nbconfbeforesimplify){ + // printf("c ### simplifyAll on conflict : %lld\n", conflicts); + //printf("nbClauses: %d, nbLearnts_core: %d, nbLearnts_tier2: %d, nbLearnts_local: %d, nbLearnts: %d\n", + // clauses.size(), learnts_core.size(), learnts_tier2.size(), learnts_local.size(), + // learnts_core.size() + learnts_tier2.size() + learnts_local.size()); + nbSimplifyAll++; + if (!simplifyAll()){ + return l_False; + } + curSimplify = (conflicts / nbconfbeforesimplify) + 1; + nbconfbeforesimplify += incSimplify; + } + + for (;;){ + if (decisionLevel() == 0) { // We import clauses + if (!importClauses()) return l_False; + } + CRef confl = propagate(); + + + if (confl != CRef_Undef){ + // CONFLICT + if (VSIDS){ + if (--timer == 0 && var_decay < 0.95) timer = 5000, var_decay += 0.01; + }else + if (step_size > min_step_size) step_size -= step_size_dec; + + conflicts++; nof_conflicts--; + //if (conflicts == 100000 && learnts_core.size() < 100) core_lbd_cut = 5; + ConflictData data = FindConflictLevel(confl); + if (data.nHighestLevel == 0) return l_False; + if (data.bOnlyOneLitFromHighest) + { + cancelUntil(data.nHighestLevel - 1); + continue; + } + + learnt_clause.clear(); + analyze(confl, learnt_clause, backtrack_level, lbd); + if (cbkExportClause != NULL) + cbkExportClause(issuer, lbd, learnt_clause); + + // check chrono backtrack condition + if ((confl_to_chrono < 0 || confl_to_chrono <= conflicts) && chrono > -1 && (decisionLevel() - backtrack_level) >= chrono) + { + ++chrono_backtrack; + cancelUntil(data.nHighestLevel -1); + } + else // default behavior + { + ++non_chrono_backtrack; + cancelUntil(backtrack_level); + } + + lbd--; + if (VSIDS){ + cached = false; + conflicts_VSIDS++; + lbd_queue.push(lbd); + global_lbd_sum += (lbd > 50 ? 50 : lbd); } + + if (learnt_clause.size() == 1){ + uncheckedEnqueue(learnt_clause[0]); + }else{ + CRef cr = ca.alloc(learnt_clause, true); + ca[cr].set_lbd(lbd); + //duplicate learnts + int id = 0; + if (lbd <= max_lbd_dup){ + std::vector tmp; + for (int i = 0; i < learnt_clause.size(); i++) + tmp.push_back(learnt_clause[i].x); + id = is_duplicate(tmp); + if (id == min_number_of_learnts_copies +1){ + duplicates_added_conflicts++; + } + if (id == min_number_of_learnts_copies){ + duplicates_added_tier2++; + } + } + //duplicate learnts + + if ((lbd <= core_lbd_cut) || (id == min_number_of_learnts_copies+1)){ + learnts_core.push(cr); + ca[cr].mark(CORE); + }else if ((lbd <= 6)||(id == min_number_of_learnts_copies)){ + learnts_tier2.push(cr); + ca[cr].mark(TIER2); + ca[cr].touched() = conflicts; + }else{ + learnts_local.push(cr); + claBumpActivity(ca[cr]); } + attachClause(cr); + + uncheckedEnqueue(learnt_clause[0], backtrack_level, cr); +#ifdef PRINT_OUT + std::cout << "new " << ca[cr] << "\n"; + std::cout << "ci " << learnt_clause[0] << " l " << backtrack_level << "\n"; +#endif + } + if (drup_file){ +#ifdef BIN_DRUP + binDRUP('a', learnt_clause, drup_file); +#else + for (int i = 0; i < learnt_clause.size(); i++) + fprintf(drup_file, "%i ", (var(learnt_clause[i]) + 1) * (-2 * sign(learnt_clause[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + } + + if (VSIDS) varDecayActivity(); + claDecayActivity(); + + /*if (--learntsize_adjust_cnt == 0){ + learntsize_adjust_confl *= learntsize_adjust_inc; + learntsize_adjust_cnt = (int)learntsize_adjust_confl; + max_learnts *= learntsize_inc; + + if (verbosity >= 1) + printf("c | %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", + (int)conflicts, + (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]), nClauses(), (int)clauses_literals, + (int)max_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progressEstimate()*100); + }*/ + + // the top_trail_soln should be update after each conflict + if(trail.size() > max_trail){ + max_trail = trail.size(); + build_soln_with_UP(); + int var_nums = nVars(); + for(int i=0;i (int)(conflict_ratio * nVars()) || trail.size() > (int)(percent_ratio * max_trail) )\ + // //&& up_time_ratio * search_start_cpu_time > ls_used_time + // ){ + + // can_call_ls = false; + // mediation_used = false; + // freeze_ls_restart_num = restarts_gap; + // bool res = call_ls(current_UP); + + // if(res){ + // solved_by_ls = true; + // return l_True; + // } + // } + + + + bool restart = false; + if (!VSIDS) + restart = nof_conflicts <= 0; + else if (!cached){ + restart = lbd_queue.full() && (lbd_queue.avg() * 0.8 > global_lbd_sum / conflicts_VSIDS); + cached = true; + } + if (restart || !withinBudget()){ + lbd_queue.clear(); + cached = false; + // Reached bound on number of conflicts: + progress_estimate = progressEstimate(); + cancelUntil(0); + return l_Undef; } + + // Simplify the set of problem clauses: + if (decisionLevel() == 0 && !simplify()) + return l_False; + + if (conflicts >= next_T2_reduce){ + next_T2_reduce = conflicts + 10000; + reduceDB_Tier2(); } + if (conflicts >= next_L_reduce){ + next_L_reduce = conflicts + 15000; + reduceDB(); } + + Lit next = lit_Undef; + /*while (decisionLevel() < assumptions.size()){ + // Perform user provided assumption: + Lit p = assumptions[decisionLevel()]; + if (value(p) == l_True){ + // Dummy decision level: + newDecisionLevel(); + }else if (value(p) == l_False){ + analyzeFinal(~p, conflict); + return l_False; + }else{ + next = p; + break; + } + } + + if (next == lit_Undef)*/{ + // New variable decision: + decisions++; + next = pickBranchLit(); + + if (next == lit_Undef) + // Model found: + return l_True; + } + + // Increase decision level and enqueue 'next' + newDecisionLevel(); + uncheckedEnqueue(next, decisionLevel()); +#ifdef PRINT_OUT + std::cout << "d " << next << " l " << decisionLevel() << "\n"; +#endif + } + } +} + + +double Solver::progressEstimate() const +{ + double progress = 0; + double F = 1.0 / nVars(); + + for (int i = 0; i <= decisionLevel(); i++){ + int beg = i == 0 ? 0 : trail_lim[i - 1]; + int end = i == decisionLevel() ? trail.size() : trail_lim[i]; + progress += pow(F, i) * (end - beg); + } + + return progress / nVars(); +} + +/* + Finite subsequences of the Luby-sequence: + + 0: 1 + 1: 1 1 2 + 2: 1 1 2 1 1 2 4 + 3: 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8 + ... + + + */ + +static double luby(double y, int x){ + + // Find the finite subsequence that contains index 'x', and the + // size of that subsequence: + int size, seq; + for (size = 1, seq = 0; size < x+1; seq++, size = 2*size+1); + + while (size-1 != x){ + size = (size-1)>>1; + seq--; + x = x % size; + } + + return pow(y, seq); +} + +static bool switch_mode = false; +static void SIGALRM_switch(int signum) { switch_mode = true; } + +// NOTE: assumptions passed in member-variable 'assumptions'. +lbool Solver::solve_() +{ + // signal(SIGALRM, SIGALRM_switch); + // alarm(2500); + restarts_gap = 300; + restarts_basic = 300; + // if trail.size() over c*nVars or p*max_trail, call ls. + // float conflict_ratio = 0.4; + // float percent_ratio = 0.9; + // // control ls time total use. + // float up_time_ratio = 0.2; + // control ls memory use per call. + ls_mems_num = 50*1000*1000; + // whether the mediation_soln is used as rephase, if not + // bool mediation_used = false; + + switch_heristic_mod = 500;//starts + last_switch_conflicts; + + //informations + // bool lssolver_constructed = false; + freeze_ls_restart_num = 0; + ls_used_time = 0; + ls_call_num = 0; + ls_best_unsat_num = INT_MAX; + solved_by_ls = false; + max_trail = 0; + max_trail_improved = false; + up_build_num = 0; + up_build_time = 0.0; + + + ccanr_has_constructed=false; + model.clear(); + conflict.clear(); + if (!ok) return l_False; + + solves++; + + max_learnts = nClauses() * learntsize_factor; + learntsize_adjust_confl = learntsize_adjust_start_confl; + learntsize_adjust_cnt = (int)learntsize_adjust_confl; + lbool status = l_Undef; + + + ls_mediation_soln = new char[nVars()+2]; + ls_best_soln = new char[nVars()+2]; + top_trail_soln = new char[nVars()+2]; + tmp_up_build_soln = new char[nVars()+2]; + + if (verbosity >= 1){ + printf("c ============================[ Search Statistics ]==============================\n"); + printf("c | Conflicts | ORIGINAL | LEARNT | Progress |\n"); + printf("c | | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n"); + printf("c ===============================================================================\n"); + } + + add_tmp.clear(); + + lssolver = (CCAnr*)malloc(sizeof(CCAnr)*1); + int fls_res = call_ls(current_UP); + if(fls_res){ + status = l_True; + } + for(int i=0;i 0 && withinBudget()) + status = search(init); + VSIDS = false; + + duplicates_added_conflicts = 0; + duplicates_added_minimization=0; + duplicates_added_tier2 =0; + + dupl_db_size=0; + size_t dupl_db_size_limit = dupl_db_init_size; + + // Search: + int curr_restarts = 0; + last_switch_conflicts = starts; + while (status == l_Undef && withinBudget()){ + if (dupl_db_size >= dupl_db_size_limit){ + // printf("c Duplicate learnts added (Minimization) %i.\n",duplicates_added_minimization); + // printf("c Duplicate learnts added (conflicts) %i.\n",duplicates_added_conflicts); + // printf("c Duplicate learnts added (tier2) %i.\n",duplicates_added_tier2); + // printf("c Duptime: %i\n",duptime.count()); + // printf("c Number of conflicts: %i\n",conflicts); + // printf("c Core size: %i\n",learnts_core.size()); + + uint32_t removed_duplicates = 0; + std::vector> tmp; + //std::map>> ht; + for (auto & outer_mp: ht){//variables + for (auto &inner_mp:outer_mp.second){//sizes + for (auto &in_in_mp: inner_mp.second){ + if (in_in_mp.second >= min_number_of_learnts_copies){ + tmp.push_back({outer_mp.first,inner_mp.first,in_in_mp.first,in_in_mp.second}); + } + } + } + } + removed_duplicates = dupl_db_size-tmp.size(); + ht.clear(); + for (auto i=0;i switch_heristic_mod){ + if(VSIDS){ + VSIDS = false; + }else{ + VSIDS = true; +// picked.clear(); +// conflicted.clear(); +// almost_conflicted.clear(); +// #ifdef ANTI_EXPLORATION +// canceled.clear(); +// #endif + } + last_switch_conflicts = starts; +// cout<<"c Swith"<= 1) + printf("c ===============================================================================\n"); + +#ifdef BIN_DRUP + if (drup_file && status == l_False) binDRUP_flush(drup_file); +#endif + + if (status == l_True){ + // Extend & copy model: + model.growTo(nVars()); + if(solved_by_ls) + for (int i = 0; i < nVars(); i++) model[i] = ls_mediation_soln[i]?l_True:l_False; + else + for (int i = 0; i < nVars(); i++) model[i] = value(i); + + }else if (status == l_False && conflict.size() == 0) + ok = false; + + cancelUntil(0); + delete [] ls_mediation_soln; + delete [] ls_best_soln; + delete [] top_trail_soln; + delete [] tmp_up_build_soln; + if (lssolver) { + free_memory(lssolver); + free(lssolver); + } + lssolver = NULL; + return status; +} + +//================================================================================================= +// Writing CNF to DIMACS: +// +// FIXME: this needs to be rewritten completely. + +static Var mapVar(Var x, vec& map, Var& max) +{ + if (map.size() <= x || map[x] == -1){ + map.growTo(x+1, -1); + map[x] = max++; + } + return map[x]; +} + + +void Solver::toDimacs(FILE* f, Clause& c, vec& map, Var& max) +{ + if (satisfied(c)) return; + + for (int i = 0; i < c.size(); i++) + if (value(c[i]) != l_False) + fprintf(f, "%s%d ", sign(c[i]) ? "-" : "", mapVar(var(c[i]), map, max)+1); + fprintf(f, "0\n"); +} + + +void Solver::toDimacs(const char *file, const vec& assumps) +{ + FILE* f = fopen(file, "wr"); + if (f == NULL) + fprintf(stderr, "could not open file %s\n", file), exit(1); + toDimacs(f, assumps); + fclose(f); +} + + +void Solver::toDimacs(FILE* f, const vec& assumps) +{ + // Handle case when solver is in contradictory state: + if (!ok){ + fprintf(f, "p cnf 1 2\n1 0\n-1 0\n"); + return; } + + vec map; Var max = 0; + + // Cannot use removeClauses here because it is not safe + // to deallocate them at this point. Could be improved. + int cnt = 0; + for (int i = 0; i < clauses.size(); i++) + if (!satisfied(ca[clauses[i]])) + cnt++; + + for (int i = 0; i < clauses.size(); i++) + if (!satisfied(ca[clauses[i]])){ + Clause& c = ca[clauses[i]]; + for (int j = 0; j < c.size(); j++) + if (value(c[j]) != l_False) + mapVar(var(c[j]), map, max); + } + + // Assumptions are added as unit clauses: + cnt += assumptions.size(); + + fprintf(f, "p cnf %d %d\n", max, cnt); + + for (int i = 0; i < assumptions.size(); i++){ + assert(value(assumptions[i]) != l_False); + fprintf(f, "%s%d 0\n", sign(assumptions[i]) ? "-" : "", mapVar(var(assumptions[i]), map, max)+1); + } + + for (int i = 0; i < clauses.size(); i++) + toDimacs(f, ca[clauses[i]], map, max); + + if (verbosity > 0) + printf("c Wrote %d clauses with %d variables.\n", cnt, max); +} + + +//================================================================================================= +// Garbage Collection methods: + +void Solver::relocAll(ClauseAllocator& to) +{ + // All watchers: + // + // for (int i = 0; i < watches.size(); i++) + watches.cleanAll(); + watches_bin.cleanAll(); + for (int v = 0; v < nVars(); v++) + for (int s = 0; s < 2; s++){ + Lit p = mkLit(v, s); + // printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1); + vec& ws = watches[p]; + for (int j = 0; j < ws.size(); j++) + ca.reloc(ws[j].cref, to); + vec& ws_bin = watches_bin[p]; + for (int j = 0; j < ws_bin.size(); j++) + ca.reloc(ws_bin[j].cref, to); + } + + // All reasons: + // + for (int i = 0; i < trail.size(); i++){ + Var v = var(trail[i]); + + if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)]))) + ca.reloc(vardata[v].reason, to); + } + + // All learnt: + // + for (int i = 0; i < learnts_core.size(); i++) + ca.reloc(learnts_core[i], to); + for (int i = 0; i < learnts_tier2.size(); i++) + ca.reloc(learnts_tier2[i], to); + for (int i = 0; i < learnts_local.size(); i++) + ca.reloc(learnts_local[i], to); + + // All original: + // + int i, j; + for (i = j = 0; i < clauses.size(); i++) + if (ca[clauses[i]].mark() != 1){ + ca.reloc(clauses[i], to); + clauses[j++] = clauses[i]; } + clauses.shrink(i - j); +} + + +void Solver::garbageCollect() +{ + // Initialize the next region to a size corresponding to the estimated utilization degree. This + // is not precise but should avoid some unnecessary reallocations for the new region: + ClauseAllocator to(ca.size() - ca.wasted()); + + relocAll(to); + if (verbosity >= 2) + printf("c | Garbage collection: %12d bytes => %12d bytes |\n", + ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size); + to.moveTo(ca); +} + + + + +void Solver::load_ls_data(){ + using namespace std; + int ls_var_nums = nVars(); + int ls_cls_nums = nClauses()+learnts_core.size()+learnts_tier2.size(); + int ls_trail_sz; + if(trail_lim.size()>0) ls_trail_sz = trail_lim[0]; + else ls_trail_sz = trail.size(); + ls_cls_nums += ls_trail_sz; + lssolver->num_vars = ls_var_nums; + lssolver->num_clauses = ls_cls_nums; + lssolver->mems_left = (long long) ls_mems_num; + lssolver->ratio = (lssolver->num_clauses+0.0)/lssolver->num_vars; + alloc_memory(lssolver); + for (int c = 0; c < lssolver->num_clauses; c++) + lssolver->clause_lit_count[c] = lssolver->clause_delete[c] = 0; + for (int v=1; v<=lssolver->num_vars; ++v) + lssolver->var_lit_count[v] = lssolver->fix[v] = 0; + lssolver->max_clause_len = 0; + lssolver->min_clause_len = lssolver->num_vars; + + using namespace std; + int cls_ct = 0; + for(int idx=0;idx<3;++idx){ + vec &vs = (idx==0)?clauses:(idx==1?learnts_core:(idx==2?learnts_tier2:learnts_local)); + int vs_sz = vs.size(); + for(int j=0;jclause_lit_count[cls_ct] = c.size(); + lssolver->clause_lit[cls_ct] = (lit*)malloc(sizeof(lit)*(lssolver->clause_lit_count[cls_ct]+1)); + int i=0; + for(;iclause_lit_count[cls_ct];i++){ + int cur_lit = toFormal(c[i]); + lssolver->clause_lit[cls_ct][i].clause_num = cls_ct; + lssolver->clause_lit[cls_ct][i].var_num = abs(cur_lit); + if (cur_lit > 0) lssolver->clause_lit[cls_ct][i].sense = 1; + else lssolver->clause_lit[cls_ct][i].sense = 0; + lssolver->var_lit_count[lssolver->clause_lit[cls_ct][i].var_num]++; + } + lssolver->clause_lit[cls_ct][i].var_num=0; + lssolver->clause_lit[cls_ct][i].clause_num = -1; + //unit clause + if(lssolver->clause_lit_count[cls_ct]==1){ + lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[cls_ct][0]; + lssolver->clause_delete[cls_ct]=1; + lssolver->clause_lit_count[cls_ct]=0; + } + if(lssolver->clause_lit_count[cls_ct] > lssolver->max_clause_len) + lssolver->max_clause_len = lssolver->clause_lit_count[cls_ct]; + else if(lssolver->clause_lit_count[cls_ct] < lssolver->min_clause_len) + lssolver->min_clause_len = lssolver->clause_lit_count[cls_ct]; + lssolver->formula_len += lssolver->clause_lit_count[cls_ct]; + + cls_ct++; + } + } + for(int j=0;jclause_lit_count[cls_ct] = 1; + lssolver->clause_lit[cls_ct] = (lit*)malloc(sizeof(lit)*(2)); + lssolver->clause_lit[cls_ct][0].clause_num = cls_ct; + lssolver->clause_lit[cls_ct][0].var_num = abs(cur_lit); + if (cur_lit > 0) lssolver->clause_lit[cls_ct][0].sense = 1; + else lssolver->clause_lit[cls_ct][0].sense = 0; + lssolver->var_lit_count[lssolver->clause_lit[cls_ct][0].var_num]++; + lssolver->clause_lit[cls_ct][1].var_num=0; + lssolver->clause_lit[cls_ct][1].clause_num=-1; + lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[cls_ct][0]; + lssolver->clause_delete[cls_ct]=1; + lssolver->clause_lit_count[cls_ct]=0; + if(lssolver->min_clause_len > 1)lssolver->min_clause_len = 1; + lssolver->formula_len += 1; + cls_ct++; + } + + for (int c = 0; c < lssolver->num_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) { + continue; + } + + for(int i=0; iclause_lit_count[c]; ++i) + { + int v = lssolver->clause_lit[c][i].var_num; + + if (v > 0 && v <= lssolver->num_vars); + else { + printf("\n111wrong v %d clause id: %d\n", v, c); + for(int ii=0; iiclause_lit_count[c]; ++ii) + printf("%d ", lssolver->clause_lit[c][ii].var_num); + puts(""); + } + if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses); + else printf("111wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]); + + } + } + // printf("finish check 1\n"); + // ofstream fout("test.txt"); + + // for (int c = 0; c < lssolver->num_clauses; ++c) + // { + // if(lssolver->clause_delete[c]==1) { + // continue; + // } + // fout << c << ": "; + // for(int i=0; iclause_lit_count[c]; ++i) + // { + // int v = lssolver->clause_lit[c][i].var_num; + // int p = lssolver->clause_lit[c][i].sense; + // fout << (p==1 ? v:-v) << " "; + // } + // fout << endl; + // } + // fout.close(); + update_after_build(lssolver); + for (int c = 0; c < lssolver->num_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) { + continue; + } + + for(int i=0; iclause_lit_count[c]; ++i) + { + int v = lssolver->clause_lit[c][i].var_num; + + if (v > 0 && v <= lssolver->num_vars); + else { + printf("\n333wrong v %d clause id: %d\n", v, c); + for(int ii=0; iiclause_lit_count[c]; ++ii) + printf("%d ", lssolver->clause_lit[c][ii].var_num); + puts(""); + } + if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses); + else printf("333wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]); + + } + } + // printf("finish check 3\n"); +} + +void Solver::build_soln_with_UP(){ + #include + using std::vector; + double start_time = cpuTime(); + int var_nums = nVars(); + int trl_sz = trail.size(); + int trl_loc = qhead; + Lit* trl = new Lit[var_nums+1]; + int undef_vars_sz = 0; + int* undef_vars = new int[var_nums+1]; + int* idx_in_undef_vars = new int[var_nums+1]; + // -1 undef, 0 false, 1 true + for(int i=0;i0){ + while(trl_loc0){ + Lit &p = trl[trl_loc++]; + + // watch binary codes + vec& ws_bin = watches_bin[p]; + int ws_bin_sz = ws_bin.size(); + for(int k=0;k& ws = watches[p]; + Watcher *i,*j,*end; + for(i=j=(Watcher*)ws,end=i+ws.size();i!=end;){ + Lit blocker = i->blocker; + // the clause is already SAT + if(tmp_up_build_soln[var(blocker)]==!sign(blocker)){*j++ = *i++;continue;} + + CRef cr = i->cref; + Clause& c = ca[cr]; + + // make sure c[1] is the false_lit to swap + Lit false_lit = ~p; + if(c[0]==false_lit) c[0]=c[1],c[1]=false_lit; + i++; + + // judge if the first lit is l_true + Lit first = c[0]; + Var first_var = var(first); + Watcher w = Watcher(cr,first); + if(first!=blocker && tmp_up_build_soln[first_var]==!sign(first)){*j++ = w; continue;} + + // first is l_false or l_undef + // then find another !l_false lit + int c_sz = c.size(); + bool should_goto_next_cls = false; + for(int k=2;kunsat_stack_fill_pointer; + // double construct_time = cpuTime()-start_time; + res = local_search(lssolver); + confl_trans(lssolver); + int ls_var_nums=nVars(); + for(int i=0;ibest_soln[i+1]; + if(lssolver->best_cost <= ls_best_unsat_num){ + restarts_gap-=restarts_basic; + if(restarts_gapbest_cost; + for(int i=0;ifix_var_ct)+"v,del"+to_string(lssolver->del_cls_ct)+"c)" + // <<",(v="<num_vars)+",c="+to_string(lssolver->num_clauses)+")" + // <<",(unsat:"<"<best_cost)+")" + // <<",("<step)<<"s)" + // <<",["< +#include +#include +#include +#include +#include +#include +// duplicate learnts version + + +// Don't change the actual numbers. +#define LOCAL 0 +#define TIER2 2 +#define CORE 3 + +namespace Minisat { + +//================================================================================================= +// Solver -- the main class: + +class Solver { +private: + template + class MyQueue { + int max_sz, q_sz; + int ptr; + int64_t sum; + vec q; + public: + MyQueue(int sz) : max_sz(sz), q_sz(0), ptr(0), sum(0) { assert(sz > 0); q.growTo(sz); } + inline bool full () const { return q_sz == max_sz; } +#ifdef INT_QUEUE_AVG + inline T avg () const { assert(full()); return sum / max_sz; } +#else + inline double avg () const { assert(full()); return sum / (double) max_sz; } +#endif + inline void clear() { sum = 0; q_sz = 0; ptr = 0; } + void push(T e) { + if (q_sz < max_sz) q_sz++; + else sum -= q[ptr]; + sum += e; + q[ptr++] = e; + if (ptr == max_sz) ptr = 0; + } + }; + +public: + // Constructor/Destructor: + // + Solver(); + virtual ~Solver(); + + // Problem specification: + // + Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode. + bool addClause (const vec& ps); // Add a clause to the solver. + bool addEmptyClause(); // Add the empty clause, making the solver contradictory. + bool addClause (Lit p); // Add a unit clause to the solver. + bool addClause (Lit p, Lit q); // Add a binary clause to the solver. + bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver. + bool addClause_( vec& ps); // Add a clause to the solver without making superflous internal copy. Will + // change the passed vector 'ps'. + + // Parallel support + // + bool importClauses(); + + vec importedClause; + void * issuer; // used as the callback parameter + + bool (* cbkImportClause)(void *, int *, vec &); + void (* cbkExportClause)(void *, int, vec &); // callback for clause learning + + // Solving: + // + bool simplify (); // Removes already satisfied clauses. + bool solve (const vec& assumps); // Search for a model that respects a given set of assumptions. + lbool solveLimited (const vec& assumps); // Search for a model that respects a given set of assumptions (With resource constraints). + bool solve (); // Search without assumptions. + bool solve (Lit p); // Search for a model that respects a single assumption. + bool solve (Lit p, Lit q); // Search for a model that respects two assumptions. + bool solve (Lit p, Lit q, Lit r); // Search for a model that respects three assumptions. + bool okay () const; // FALSE means solver is in a conflicting state + + void toDimacs (FILE* f, const vec& assumps); // Write CNF to file in DIMACS-format. + void toDimacs (const char *file, const vec& assumps); + void toDimacs (FILE* f, Clause& c, vec& map, Var& max); + + // Convenience versions of 'toDimacs()': + void toDimacs (const char* file); + void toDimacs (const char* file, Lit p); + void toDimacs (const char* file, Lit p, Lit q); + void toDimacs (const char* file, Lit p, Lit q, Lit r); + + // Variable mode: + // + void setPolarity (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'. + void setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic. + + // Read state: + // + lbool value (Var x) const; // The current value of a variable. + lbool value (Lit p) const; // The current value of a literal. + lbool modelValue (Var x) const; // The value of a variable in the last model. The last call to solve must have been satisfiable. + lbool modelValue (Lit p) const; // The value of a literal in the last model. The last call to solve must have been satisfiable. + int nAssigns () const; // The current number of assigned literals. + int nClauses () const; // The current number of original clauses. + int nLearnts () const; // The current number of learnt clauses. + int nVars () const; // The current number of variables. + int nFreeVars () const; + + // Resource contraints: + // + void setConfBudget(int64_t x); + void setPropBudget(int64_t x); + void budgetOff(); + void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver. + void clearInterrupt(); // Clear interrupt indicator flag. + + // Memory managment: + // + virtual void garbageCollect(); + void checkGarbage(double gf); + void checkGarbage(); + + // Extra results: (read-only member variable) + // + vec model; // If problem is satisfiable, this vector contains the model (if any). + vec conflict; // If problem is unsatisfiable (possibly under assumptions), + // this vector represent the final conflict clause expressed in the assumptions. + + // Mode of operation: + // + FILE* drup_file; + int worker_index; + int worker_number; + int worker_seed; + int verbosity; + double step_size; + double step_size_dec; + double min_step_size; + int timer; + double var_decay; + double clause_decay; + double random_var_freq; + double random_seed; + bool VSIDS; + int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep). + int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full). + bool rnd_pol; // Use random polarities for branching heuristics. + bool rnd_init_act; // Initialize variable activities with a small random value. + double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered. + + int restart_first; // The initial restart limit. (default 100) + double restart_inc; // The factor with which the restart limit is multiplied in each restart. (default 1.5) + double learntsize_factor; // The intitial limit for learnt clauses is a factor of the original clauses. (default 1 / 3) + double learntsize_inc; // The limit for learnt clauses is multiplied with this factor each restart. (default 1.1) + + int learntsize_adjust_start_confl; + double learntsize_adjust_inc; + + + // duplicate learnts version + + uint32_t min_number_of_learnts_copies; + uint32_t dupl_db_init_size; + uint32_t max_lbd_dup; + std::chrono::microseconds duptime; + // duplicate learnts version + + // Statistics: (read-only member variable) + // + uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, conflicts_VSIDS; + uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals; + uint64_t chrono_backtrack, non_chrono_backtrack; + + + // duplicate learnts version + uint64_t duplicates_added_conflicts; + uint64_t duplicates_added_tier2; + uint64_t duplicates_added_minimization; + uint64_t dupl_db_size; + + // duplicate learnts version + + vec picked; + vec conflicted; + vec almost_conflicted; +#ifdef ANTI_EXPLORATION + vec canceled; +#endif + +protected: + + // Helper structures: + // + struct VarData { CRef reason; int level; }; + static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; } + + struct Watcher { + CRef cref; + Lit blocker; + Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {} + bool operator==(const Watcher& w) const { return cref == w.cref; } + bool operator!=(const Watcher& w) const { return cref != w.cref; } + }; + + struct WatcherDeleted + { + const ClauseAllocator& ca; + WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {} + bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; } + }; + + struct VarOrderLt { + const vec& activity; + bool operator () (Var x, Var y) const { return activity[x] > activity[y]; } + VarOrderLt(const vec& act) : activity(act) { } + }; + + struct ConflictData + { + ConflictData() : + nHighestLevel(-1), + bOnlyOneLitFromHighest(false) + {} + + int nHighestLevel; + bool bOnlyOneLitFromHighest; + }; + + // Solver state: + // + bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used! + vec clauses; // List of problem clauses. + vec learnts_core, // List of learnt clauses. + learnts_tier2, + learnts_local; + double cla_inc; // Amount to bump next clause with. + vec activity_CHB, // A heuristic measurement of the activity of a variable. + activity_VSIDS; + double var_inc; // Amount to bump next variable with. + OccLists, WatcherDeleted> + watches_bin, // Watches for binary clauses only. + watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true). + vec assigns; // The current assignments. + vec polarity; // The preferred polarity of each variable. + vec decision; // Declares if a variable is eligible for selection in the decision heuristic. + vec trail; // Assignment stack; stores all assigments made in the order they were made. + vec trail_lim; // Separator indices for different decision levels in 'trail'. + vec vardata; // Stores reason and level for each variable. + int qhead; // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat). + int simpDB_assigns; // Number of top-level assignments since last execution of 'simplify()'. + int64_t simpDB_props; // Remaining number of propagations that must be made before next execution of 'simplify()'. + vec assumptions; // Current set of assumptions provided to solve by the user. + Heap order_heap_CHB, // A priority queue of variables ordered with respect to the variable activity. + order_heap_VSIDS; + double progress_estimate;// Set by 'search()'. + bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'. + + int core_lbd_cut; + float global_lbd_sum; + MyQueue lbd_queue; // For computing moving averages of recent LBD values. + + uint64_t next_T2_reduce, + next_L_reduce; + + ClauseAllocator ca; + + // duplicate learnts version + std::map>> ht; + + // duplicate learnts version + + int confl_to_chrono; + int chrono; + + // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is + // used, exept 'seen' wich is used in several places. + // + vec seen; + vec analyze_stack; + vec analyze_toclear; + vec add_tmp; + vec add_oc; + + vec seen2; // Mostly for efficient LBD computation. 'seen2[i]' will indicate if decision level or variable 'i' has been seen. + uint64_t counter; // Simple counter for marking purpose with 'seen2'. + + double max_learnts; + double learntsize_adjust_confl; + int learntsize_adjust_cnt; + + // Resource contraints: + // + int64_t conflict_budget; // -1 means no budget. + int64_t propagation_budget; // -1 means no budget. + bool asynch_interrupt; + + // Main internal methods: + // + void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. + Lit pickBranchLit (); // Return the next decision variable. + void newDecisionLevel (); // Begins a new decision level. + void uncheckedEnqueue (Lit p, int level = 0, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. + bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise. + CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause. + void cancelUntil (int level); // Backtrack until a certain level. + void analyze (CRef confl, vec& out_learnt, int& out_btlevel, int& out_lbd); // (bt = backtrack) + void analyzeFinal (Lit p, vec& out_conflict); // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION? + bool litRedundant (Lit p, uint32_t abstract_levels); // (helper method for 'analyze()') + lbool search (int& nof_conflicts); // Search for a given number of conflicts. + lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). + void reduceDB (); // Reduce the set of learnt clauses. + void reduceDB_Tier2 (); + void removeSatisfied (vec& cs); // Shrink 'cs' to contain only non-satisfied clauses. + void safeRemoveSatisfied(vec& cs, unsigned valid_mark); + void rebuildOrderHeap (); + bool binResMinimize (vec& out_learnt); // Further learnt clause minimization by binary resolution. + + // Maintaining Variable/Clause activity: + // + void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead. + void varBumpActivity (Var v, double mult); // Increase a variable with the current 'bump' value. + void claDecayActivity (); // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead. + void claBumpActivity (Clause& c); // Increase a clause with the current 'bump' value. + + // Operations on clauses: + // + void attachClause (CRef cr); // Attach a clause to watcher lists. + void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists. + void removeClause (CRef cr); // Detach and free a clause. + bool locked (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state. + bool satisfied (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state. + + void relocAll (ClauseAllocator& to); + +// duplicate learnts version + int is_duplicate (std::vector&c); //returns TRUE if a clause is duplicate +// duplicate learnts version + + // Misc: + // + int decisionLevel () const; // Gives the current decisionlevel. + uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels. + CRef reason (Var x) const; + + ConflictData FindConflictLevel(CRef cind); + +public: + int level (Var x) const; +protected: + double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ... + bool withinBudget () const; + + template int computeLBD(const V& c) { + int lbd = 0; + + counter++; + for (int i = 0; i < c.size(); i++){ + int l = level(var(c[i])); + if (l != 0 && seen2[l] != counter){ + seen2[l] = counter; + lbd++; } } + + return lbd; + } + +#ifdef BIN_DRUP + static int buf_len; + static unsigned char drup_buf[]; + static unsigned char* buf_ptr; + + static inline void byteDRUP(Lit l){ + unsigned int u = 2 * (var(l) + 1) + sign(l); + do{ + *buf_ptr++ = u & 0x7f | 0x80; buf_len++; + u = u >> 7; + }while (u); + *(buf_ptr - 1) &= 0x7f; // End marker of this unsigned number. + } + + template + static inline void binDRUP(unsigned char op, const V& c, FILE* drup_file){ + assert(op == 'a' || op == 'd'); + *buf_ptr++ = op; buf_len++; + for (int i = 0; i < c.size(); i++) byteDRUP(c[i]); + *buf_ptr++ = 0; buf_len++; + if (buf_len > 1048576) binDRUP_flush(drup_file); + } + + static inline void binDRUP_strengthen(const Clause& c, Lit l, FILE* drup_file){ + *buf_ptr++ = 'a'; buf_len++; + for (int i = 0; i < c.size(); i++) + if (c[i] != l) byteDRUP(c[i]); + *buf_ptr++ = 0; buf_len++; + if (buf_len > 1048576) binDRUP_flush(drup_file); + } + + static inline void binDRUP_flush(FILE* drup_file){ +// fwrite(drup_buf, sizeof(unsigned char), buf_len, drup_file); + fwrite_unlocked(drup_buf, sizeof(unsigned char), buf_len, drup_file); + buf_ptr = drup_buf; buf_len = 0; + } +#endif + + // Static helpers: + // + + // Returns a random float 0 <= x < 1. Seed must never be 0. + static inline double drand(double& seed) { + seed *= 1389796; + int q = (int)(seed / 2147483647); + seed -= (double)q * 2147483647; + return seed / 2147483647; } + + // Returns a random integer 0 <= x < size. Seed must never be 0. + static inline int irand(double& seed, int size) { + return (int)(drand(seed) * size); } + + + // simplify + // +public: + bool simplifyAll(); + void simplifyLearnt(Clause& c); + bool simplifyLearnt_x(vec& learnts_x); + bool simplifyLearnt_core(); + bool simplifyLearnt_tier2(); + int trailRecord; + void litsEnqueue(int cutP, Clause& c); + void cancelUntilTrailRecord(); + void simpleUncheckEnqueue(Lit p, CRef from = CRef_Undef); + CRef simplePropagate(); + uint64_t nbSimplifyAll; + uint64_t simplified_length_record, original_length_record; + uint64_t s_propagations; + + vec simp_learnt_clause; + vec simp_reason_clause; + void simpleAnalyze(CRef confl, vec& out_learnt, vec& reason_clause, bool True_confl); + + // in redundant + bool removed(CRef cr); + // adjust simplifyAll occasion + long curSimplify; + int nbconfbeforesimplify; + int incSimplify; + +private: + // to avoid the init_soln of two LS too near. + int restarts_gap = 300; + int restarts_basic = 300; + // if trail.size() over c*nVars or p*max_trail, call ls. + // float conflict_ratio = 0.4; + // float percent_ratio = 0.9; + // // control ls time total use. + // float up_time_ratio = 0.2; + // control ls memory use per call. + long long ls_mems_num = 50*1000*1000; + // whether the mediation_soln is used as rephase, if not + // bool mediation_used = false; + + int switch_heristic_mod = 500;//starts + int last_switch_conflicts; + + //informations + // bool lssolver_constructed = false; + CCAnr *lssolver; + int freeze_ls_restart_num = 0; + double ls_used_time = 0; + int ls_call_num = 0; + int ls_best_unsat_num = INT_MAX; + bool solved_by_ls = false; + int max_trail = 0; + bool max_trail_improved = false; + int up_build_num = 0; + double up_build_time = 0.0; + + //Phases + // save the recent ls soln and best ls soln, need to call ls once. + char* ls_mediation_soln; + // with the minimum unsat clauses num in LS. + char* ls_best_soln; + // hold the soln with the best trail size. + char* top_trail_soln; + char* tmp_up_build_soln; + + + //functions + // bool call_ls(bool use_up_build); + bool ccanr_has_constructed = false; + enum build_type{current_UP,top_trail_UP,random_build}; + bool call_ls(build_type type); + void load_ls_data(); + void build_soln_with_UP(); + void rand_based_rephase(); + void info_based_rephase(); +}; + + +//================================================================================================= +// Implementation of inline methods: + +inline CRef Solver::reason(Var x) const { return vardata[x].reason; } +inline int Solver::level (Var x) const { return vardata[x].level; } + +inline void Solver::insertVarOrder(Var x) { + // Heap& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB; + Heap& order_heap = ((!VSIDS)? order_heap_CHB:order_heap_VSIDS); + if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); } + +inline void Solver::varDecayActivity() { + var_inc *= (1 / var_decay); } + +inline void Solver::varBumpActivity(Var v, double mult) { + if ( (activity_VSIDS[v] += var_inc * mult) > 1e100 ) { + // Rescale: + for (int i = 0; i < nVars(); i++) + activity_VSIDS[i] *= 1e-100; + var_inc *= 1e-100; } + + // Update order_heap with respect to new activity: + if (order_heap_VSIDS.inHeap(v)) order_heap_VSIDS.decrease(v); } + +inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); } +inline void Solver::claBumpActivity (Clause& c) { + if ( (c.activity() += cla_inc) > 1e20 ) { + // Rescale: + for (int i = 0; i < learnts_local.size(); i++) + ca[learnts_local[i]].activity() *= 1e-20; + cla_inc *= 1e-20; } } + +inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); } +inline void Solver::checkGarbage(double gf){ + if (ca.wasted() > ca.size() * gf) + garbageCollect(); } + +// NOTE: enqueue does not set the ok flag! (only public methods do) +inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, decisionLevel(), from), true); } +inline bool Solver::addClause (const vec& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); } +inline bool Solver::addEmptyClause () { add_tmp.clear(); return addClause_(add_tmp); } +inline bool Solver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); } +inline bool Solver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); } +inline bool Solver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); } +inline bool Solver::locked (const Clause& c) const { + int i = c.size() != 2 ? 0 : (value(c[0]) == l_True ? 0 : 1); + return value(c[i]) == l_True && reason(var(c[i])) != CRef_Undef && ca.lea(reason(var(c[i]))) == &c; +} +inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); } + +inline int Solver::decisionLevel () const { return trail_lim.size(); } +inline uint32_t Solver::abstractLevel (Var x) const { return 1 << (level(x) & 31); } +inline lbool Solver::value (Var x) const { return assigns[x]; } +inline lbool Solver::value (Lit p) const { return assigns[var(p)] ^ sign(p); } +inline lbool Solver::modelValue (Var x) const { return model[x]; } +inline lbool Solver::modelValue (Lit p) const { return model[var(p)] ^ sign(p); } +inline int Solver::nAssigns () const { return trail.size(); } +inline int Solver::nClauses () const { return clauses.size(); } +inline int Solver::nLearnts () const { return learnts_core.size() + learnts_tier2.size() + learnts_local.size(); } +inline int Solver::nVars () const { return vardata.size(); } +inline int Solver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); } +inline void Solver::setPolarity (Var v, bool b) { polarity[v] = b; } +inline void Solver::setDecisionVar(Var v, bool b) +{ + if ( b && !decision[v]) dec_vars++; + else if (!b && decision[v]) dec_vars--; + + decision[v] = b; + if (b && !order_heap_CHB.inHeap(v)){ + order_heap_CHB.insert(v); + order_heap_VSIDS.insert(v);} +} +inline void Solver::setConfBudget(int64_t x){ conflict_budget = conflicts + x; } +inline void Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; } +inline void Solver::interrupt(){ asynch_interrupt = true; } +inline void Solver::clearInterrupt(){ asynch_interrupt = false; } +inline void Solver::budgetOff(){ conflict_budget = propagation_budget = -1; } +inline bool Solver::withinBudget() const { + return !asynch_interrupt && + (conflict_budget < 0 || conflicts < (uint64_t)conflict_budget) && + (propagation_budget < 0 || propagations < (uint64_t)propagation_budget); } + +// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a +// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or +// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer. +inline bool Solver::solve () { budgetOff(); assumptions.clear(); return solve_() == l_True; } +inline bool Solver::solve (Lit p) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; } +inline bool Solver::solve (Lit p, Lit q) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; } +inline bool Solver::solve (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; } +inline bool Solver::solve (const vec& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; } +inline lbool Solver::solveLimited (const vec& assumps){ assumps.copyTo(assumptions); return solve_(); } +inline bool Solver::okay () const { return ok; } + +inline void Solver::toDimacs (const char* file){ vec as; toDimacs(file, as); } +inline void Solver::toDimacs (const char* file, Lit p){ vec as; as.push(p); toDimacs(file, as); } +inline void Solver::toDimacs (const char* file, Lit p, Lit q){ vec as; as.push(p); as.push(q); toDimacs(file, as); } +inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ vec as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); } + +//================================================================================================= +// Debug etc: + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/core/Solver.or b/lstech_maple/lstech/core/Solver.or new file mode 100755 index 0000000..1c3afd9 Binary files /dev/null and b/lstech_maple/lstech/core/Solver.or differ diff --git a/lstech_maple/lstech/core/SolverTypes.h b/lstech_maple/lstech/core/SolverTypes.h new file mode 100755 index 0000000..f3292c7 --- /dev/null +++ b/lstech_maple/lstech/core/SolverTypes.h @@ -0,0 +1,465 @@ +/***********************************************************************************[SolverTypes.h] +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + + +#ifndef Minisat_SolverTypes_h +#define Minisat_SolverTypes_h + +#include + +#include "mtl/IntTypes.h" +#include "mtl/Alg.h" +#include "mtl/Vec.h" +#include "mtl/Map.h" +#include "mtl/Alloc.h" +#include + +namespace Minisat { + +//================================================================================================= +// Variables, literals, lifted booleans, clauses: + + +// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N, +// so that they can be used as array indices. + +typedef int Var; +#define var_Undef (-1) + + +struct Lit { + int x; + + // Use this as a constructor: + friend Lit mkLit(Var var, bool sign ); + + bool operator == (Lit p) const { return x == p.x; } + bool operator != (Lit p) const { return x != p.x; } + bool operator < (Lit p) const { return x < p.x; } // '<' makes p, ~p adjacent in the ordering. +}; + +inline Lit mkLit (Var var, bool sign= false) { Lit p; p.x = var + var + (int)sign; return p; } +inline Lit operator ~(Lit p) { Lit q; q.x = p.x ^ 1; return q; } +inline Lit operator ^(Lit p, bool b) { Lit q; q.x = p.x ^ (unsigned int)b; return q; } +inline bool sign (Lit p) { return p.x & 1; } +inline int var (Lit p) { return p.x >> 1; } + +// Mapping Literals to and from compact integers suitable for array indexing: +inline int toInt (Var v) { return v; } +inline int toInt (Lit p) { return p.x; } +inline Lit toLit (int i) { Lit p; p.x = i; return p; } + +//const Lit lit_Undef = mkLit(var_Undef, false); // }- Useful special constants. +//const Lit lit_Error = mkLit(var_Undef, true ); // } + +const Lit lit_Undef = { -2 }; // }- Useful special constants. +const Lit lit_Error = { -1 }; // } + + +inline int toFormal(Lit p) { return sign(p) ? -var(p) - 1 : var(p) + 1; } + + +inline std::ostream& operator<<(std::ostream& out, const Lit& val) +{ + out << (sign(val) ? -var(val) : var(val)) << std::flush; + return out; +} + + + +//================================================================================================= +// Lifted booleans: +// +// NOTE: this implementation is optimized for the case when comparisons between values are mostly +// between one variable and one constant. Some care had to be taken to make sure that gcc +// does enough constant propagation to produce sensible code, and this appears to be somewhat +// fragile unfortunately. + +#define l_True (lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants. +#define l_False (lbool((uint8_t)1)) +#define l_Undef (lbool((uint8_t)2)) + +class lbool { + uint8_t value; + +public: + explicit lbool(uint8_t v) : value(v) { } + + lbool() : value(0) { } + explicit lbool(bool x) : value(!x) { } + + bool operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); } + bool operator != (lbool b) const { return !(*this == b); } + lbool operator ^ (bool b) const { return lbool((uint8_t)(value^(uint8_t)b)); } + + lbool operator && (lbool b) const { + uint8_t sel = (this->value << 1) | (b.value << 3); + uint8_t v = (0xF7F755F4 >> sel) & 3; + return lbool(v); } + + lbool operator || (lbool b) const { + uint8_t sel = (this->value << 1) | (b.value << 3); + uint8_t v = (0xFCFCF400 >> sel) & 3; + return lbool(v); } + + friend int toInt (lbool l); + friend lbool toLbool(int v); +}; +inline int toInt (lbool l) { return l.value; } +inline lbool toLbool(int v) { return lbool((uint8_t)v); } + +//================================================================================================= +// Clause -- a simple class for representing a clause: + +class Clause; +typedef RegionAllocator::Ref CRef; + +class Clause { + struct { + unsigned mark : 2; + unsigned learnt : 1; + unsigned has_extra : 1; + unsigned reloced : 1; + unsigned lbd : 26; + unsigned removable : 1; + unsigned size : 32; + //simplify + unsigned simplified : 1;} header; + union { Lit lit; float act; uint32_t abs; uint32_t touched; CRef rel; } data[0]; + + friend class ClauseAllocator; + + // NOTE: This constructor cannot be used directly (doesn't allocate enough memory). + template + Clause(const V& ps, bool use_extra, bool learnt) { + header.mark = 0; + header.learnt = learnt; + header.has_extra = learnt | use_extra; + header.reloced = 0; + header.size = ps.size(); + header.lbd = 0; + header.removable = 1; + //simplify + // + header.simplified = 0; + + for (int i = 0; i < ps.size(); i++) + data[i].lit = ps[i]; + + if (header.has_extra){ + if (header.learnt){ + data[header.size].act = 0; + data[header.size+1].touched = 0; + }else + calcAbstraction(); } + } + +public: + void calcAbstraction() { + assert(header.has_extra); + uint32_t abstraction = 0; + for (int i = 0; i < size(); i++) + abstraction |= 1 << (var(data[i].lit) & 31); + data[header.size].abs = abstraction; } + + + int size () const { return header.size; } + void shrink (int i) { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; } + void pop () { shrink(1); } + bool learnt () const { return header.learnt; } + bool has_extra () const { return header.has_extra; } + uint32_t mark () const { return header.mark; } + void mark (uint32_t m) { header.mark = m; } + const Lit& last () const { return data[header.size-1].lit; } + + bool reloced () const { return header.reloced; } + CRef relocation () const { return data[0].rel; } + void relocate (CRef c) { header.reloced = 1; data[0].rel = c; } + + int lbd () const { return header.lbd; } + void set_lbd (int lbd) { header.lbd = lbd; } + bool removable () const { return header.removable; } + void removable (bool b) { header.removable = b; } + + // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for + // subsumption operations to behave correctly. + Lit& operator [] (int i) { return data[i].lit; } + Lit operator [] (int i) const { return data[i].lit; } + operator const Lit* (void) const { return (Lit*)data; } + + uint32_t& touched () { assert(header.has_extra && header.learnt); return data[header.size+1].touched; } + float& activity () { assert(header.has_extra); return data[header.size].act; } + uint32_t abstraction () const { assert(header.has_extra); return data[header.size].abs; } + + Lit subsumes (const Clause& other) const; + void strengthen (Lit p); + // simplify + // + void setSimplified(bool b) { header.simplified = b; } + bool simplified() { return header.simplified; } +}; + + +//================================================================================================= +// ClauseAllocator -- a simple class for allocating memory for clauses: + + +const CRef CRef_Undef = RegionAllocator::Ref_Undef; +class ClauseAllocator : public RegionAllocator +{ + static int clauseWord32Size(int size, int extras){ + return (sizeof(Clause) + (sizeof(Lit) * (size + extras))) / sizeof(uint32_t); } +public: + bool extra_clause_field; + + ClauseAllocator(uint32_t start_cap) : RegionAllocator(start_cap), extra_clause_field(false){} + ClauseAllocator() : extra_clause_field(false){} + + void moveTo(ClauseAllocator& to){ + to.extra_clause_field = extra_clause_field; + RegionAllocator::moveTo(to); } + + template + CRef alloc(const Lits& ps, bool learnt = false) + { + assert(sizeof(Lit) == sizeof(uint32_t)); + assert(sizeof(float) == sizeof(uint32_t)); + int extras = learnt ? 2 : (int)extra_clause_field; + + CRef cid = RegionAllocator::alloc(clauseWord32Size(ps.size(), extras)); + new (lea(cid)) Clause(ps, extra_clause_field, learnt); + + return cid; + } + + // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): + Clause& operator[](Ref r) { return (Clause&)RegionAllocator::operator[](r); } + const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator::operator[](r); } + Clause* lea (Ref r) { return (Clause*)RegionAllocator::lea(r); } + const Clause* lea (Ref r) const { return (Clause*)RegionAllocator::lea(r); } + Ref ael (const Clause* t){ return RegionAllocator::ael((uint32_t*)t); } + + void free(CRef cid) + { + Clause& c = operator[](cid); + int extras = c.learnt() ? 2 : (int)c.has_extra(); + RegionAllocator::free(clauseWord32Size(c.size(), extras)); + } + + void reloc(CRef& cr, ClauseAllocator& to) + { + Clause& c = operator[](cr); + + if (c.reloced()) { cr = c.relocation(); return; } + + cr = to.alloc(c, c.learnt()); + c.relocate(cr); + + // Copy extra data-fields: + // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?) + to[cr].mark(c.mark()); + if (to[cr].learnt()){ + to[cr].touched() = c.touched(); + to[cr].activity() = c.activity(); + to[cr].set_lbd(c.lbd()); + to[cr].removable(c.removable()); + // simplify + // + to[cr].setSimplified(c.simplified()); + } + else if (to[cr].has_extra()) to[cr].calcAbstraction(); + } +}; + + +inline std::ostream& operator<<(std::ostream& out, const Clause& cls) +{ + for (int i = 0; i < cls.size(); ++i) + { + out << cls[i] << " "; + } + + return out; +} + +//================================================================================================= +// OccLists -- a class for maintaining occurence lists with lazy deletion: + +template +class OccLists +{ + vec occs; + vec dirty; + vec dirties; + Deleted deleted; + +public: + OccLists(const Deleted& d) : deleted(d) {} + + void init (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); } + // Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; } + Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; } + Vec& lookup (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; } + + void cleanAll (); + void clean (const Idx& idx); + void smudge (const Idx& idx){ + if (dirty[toInt(idx)] == 0){ + dirty[toInt(idx)] = 1; + dirties.push(idx); + } + } + + void clear(bool free = true){ + occs .clear(free); + dirty .clear(free); + dirties.clear(free); + } +}; + + +template +void OccLists::cleanAll() +{ + for (int i = 0; i < dirties.size(); i++) + // Dirties may contain duplicates so check here if a variable is already cleaned: + if (dirty[toInt(dirties[i])]) + clean(dirties[i]); + dirties.clear(); +} + + +template +void OccLists::clean(const Idx& idx) +{ + Vec& vec = occs[toInt(idx)]; + int i, j; + for (i = j = 0; i < vec.size(); i++) + if (!deleted(vec[i])) + vec[j++] = vec[i]; + vec.shrink(i - j); + dirty[toInt(idx)] = 0; +} + + +//================================================================================================= +// CMap -- a class for mapping clauses to values: + + +template +class CMap +{ + struct CRefHash { + uint32_t operator()(CRef cr) const { return (uint32_t)cr; } }; + + typedef Map HashTable; + HashTable map; + +public: + // Size-operations: + void clear () { map.clear(); } + int size () const { return map.elems(); } + + + // Insert/Remove/Test mapping: + void insert (CRef cr, const T& t){ map.insert(cr, t); } + void growTo (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility + void remove (CRef cr) { map.remove(cr); } + bool has (CRef cr, T& t) { return map.peek(cr, t); } + + // Vector interface (the clause 'c' must already exist): + const T& operator [] (CRef cr) const { return map[cr]; } + T& operator [] (CRef cr) { return map[cr]; } + + // Iteration (not transparent at all at the moment): + int bucket_count() const { return map.bucket_count(); } + const vec& bucket(int i) const { return map.bucket(i); } + + // Move contents to other map: + void moveTo(CMap& other){ map.moveTo(other.map); } + + // TMP debug: + void debug(){ + printf("c --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); } +}; + + +/*_________________________________________________________________________________________________ +| +| subsumes : (other : const Clause&) -> Lit +| +| Description: +| Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other' +| by subsumption resolution. +| +| Result: +| lit_Error - No subsumption or simplification +| lit_Undef - Clause subsumes 'other' +| p - The literal p can be deleted from 'other' +|________________________________________________________________________________________________@*/ +inline Lit Clause::subsumes(const Clause& other) const +{ + //if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0) + //if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0)) + assert(!header.learnt); assert(!other.header.learnt); + assert(header.has_extra); assert(other.header.has_extra); + if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0) + return lit_Error; + + Lit ret = lit_Undef; + const Lit* c = (const Lit*)(*this); + const Lit* d = (const Lit*)other; + + for (unsigned i = 0; i < header.size; i++) { + // search for c[i] or ~c[i] + for (unsigned j = 0; j < other.header.size; j++) + if (c[i] == d[j]) + goto ok; + else if (ret == lit_Undef && c[i] == ~d[j]){ + ret = c[i]; + goto ok; + } + + // did not find it + return lit_Error; +ok:; + } + + return ret; +} + +inline void Clause::strengthen(Lit p) +{ + remove(*this, p); + calcAbstraction(); +} + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Alg.h b/lstech_maple/lstech/mtl/Alg.h new file mode 100755 index 0000000..bb1ee5a --- /dev/null +++ b/lstech_maple/lstech/mtl/Alg.h @@ -0,0 +1,84 @@ +/*******************************************************************************************[Alg.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Alg_h +#define Minisat_Alg_h + +#include "mtl/Vec.h" + +namespace Minisat { + +//================================================================================================= +// Useful functions on vector-like types: + +//================================================================================================= +// Removing and searching for elements: +// + +template +static inline void remove(V& ts, const T& t) +{ + int j = 0; + for (; j < ts.size() && ts[j] != t; j++); + assert(j < ts.size()); + for (; j < ts.size()-1; j++) ts[j] = ts[j+1]; + ts.pop(); +} + + +template +static inline bool find(V& ts, const T& t) +{ + int j = 0; + for (; j < ts.size() && ts[j] != t; j++); + return j < ts.size(); +} + + +//================================================================================================= +// Copying vectors with support for nested vector types: +// + +// Base case: +template +static inline void copy(const T& from, T& to) +{ + to = from; +} + +// Recursive case: +template +static inline void copy(const vec& from, vec& to, bool append = false) +{ + if (!append) + to.clear(); + for (int i = 0; i < from.size(); i++){ + to.push(); + copy(from[i], to.last()); + } +} + +template +static inline void append(const vec& from, vec& to){ copy(from, to, true); } + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Alloc.h b/lstech_maple/lstech/mtl/Alloc.h new file mode 100755 index 0000000..76322b8 --- /dev/null +++ b/lstech_maple/lstech/mtl/Alloc.h @@ -0,0 +1,131 @@ +/*****************************************************************************************[Alloc.h] +Copyright (c) 2008-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + + +#ifndef Minisat_Alloc_h +#define Minisat_Alloc_h + +#include "mtl/XAlloc.h" +#include "mtl/Vec.h" + +namespace Minisat { + +//================================================================================================= +// Simple Region-based memory allocator: + +template +class RegionAllocator +{ + T* memory; + uint32_t sz; + uint32_t cap; + uint32_t wasted_; + + void capacity(uint32_t min_cap); + + public: + // TODO: make this a class for better type-checking? + typedef uint32_t Ref; + enum { Ref_Undef = UINT32_MAX }; + enum { Unit_Size = sizeof(uint32_t) }; + + explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); } + ~RegionAllocator() + { + if (memory != NULL) + ::free(memory); + } + + + uint32_t size () const { return sz; } + uint32_t wasted () const { return wasted_; } + + Ref alloc (int size); + void free (int size) { wasted_ += size; } + + // Deref, Load Effective Address (LEA), Inverse of LEA (AEL): + T& operator[](Ref r) { assert(r >= 0 && r < sz); return memory[r]; } + const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; } + + T* lea (Ref r) { assert(r >= 0 && r < sz); return &memory[r]; } + const T* lea (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; } + Ref ael (const T* t) { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]); + return (Ref)(t - &memory[0]); } + + void moveTo(RegionAllocator& to) { + if (to.memory != NULL) ::free(to.memory); + to.memory = memory; + to.sz = sz; + to.cap = cap; + to.wasted_ = wasted_; + + memory = NULL; + sz = cap = wasted_ = 0; + } + + +}; + +template +void RegionAllocator::capacity(uint32_t min_cap) +{ + if (cap >= min_cap) return; + + uint32_t prev_cap = cap; + while (cap < min_cap){ + // NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the + // result even by clearing the least significant bit. The resulting sequence of capacities + // is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when + // using 'uint32_t' as indices so that as much as possible of this space can be used. + uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1; + cap += delta; + + if (cap <= prev_cap) + throw OutOfMemoryException(); + } + // printf(" .. (%p) cap = %u\n", this, cap); + + assert(cap > 0); + memory = (T*)xrealloc(memory, sizeof(T)*cap); +} + + +template +typename RegionAllocator::Ref +RegionAllocator::alloc(int size) +{ + // printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout); + assert(size > 0); + capacity(sz + size); + + uint32_t prev_sz = sz; + sz += size; + + // Handle overflow: + if (sz < prev_sz) + throw OutOfMemoryException(); + + return prev_sz; +} + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Heap.h b/lstech_maple/lstech/mtl/Heap.h new file mode 100755 index 0000000..b73f9e2 --- /dev/null +++ b/lstech_maple/lstech/mtl/Heap.h @@ -0,0 +1,148 @@ +/******************************************************************************************[Heap.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Heap_h +#define Minisat_Heap_h + +#include "mtl/Vec.h" + +namespace Minisat { + +//================================================================================================= +// A heap implementation with support for decrease/increase key. + + +template +class Heap { + Comp lt; // The heap is a minimum-heap with respect to this comparator + vec heap; // Heap of integers + vec indices; // Each integers position (index) in the Heap + + // Index "traversal" functions + static inline int left (int i) { return i*2+1; } + static inline int right (int i) { return (i+1)*2; } + static inline int parent(int i) { return (i-1) >> 1; } + + + void percolateUp(int i) + { + int x = heap[i]; + int p = parent(i); + + while (i != 0 && lt(x, heap[p])){ + heap[i] = heap[p]; + indices[heap[p]] = i; + i = p; + p = parent(p); + } + heap [i] = x; + indices[x] = i; + } + + + void percolateDown(int i) + { + int x = heap[i]; + while (left(i) < heap.size()){ + int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i); + if (!lt(heap[child], x)) break; + heap[i] = heap[child]; + indices[heap[i]] = i; + i = child; + } + heap [i] = x; + indices[x] = i; + } + + + public: + Heap(const Comp& c) : lt(c) { } + + int size () const { return heap.size(); } + bool empty () const { return heap.size() == 0; } + bool inHeap (int n) const { return n < indices.size() && indices[n] >= 0; } + int operator[](int index) const { assert(index < heap.size()); return heap[index]; } + + + void decrease (int n) { assert(inHeap(n)); percolateUp (indices[n]); } + void increase (int n) { assert(inHeap(n)); percolateDown(indices[n]); } + + + // Safe variant of insert/decrease/increase: + void update(int n) + { + if (!inHeap(n)) + insert(n); + else { + percolateUp(indices[n]); + percolateDown(indices[n]); } + } + + + void insert(int n) + { + indices.growTo(n+1, -1); + assert(!inHeap(n)); + + indices[n] = heap.size(); + heap.push(n); + percolateUp(indices[n]); + } + + + int removeMin() + { + int x = heap[0]; + heap[0] = heap.last(); + indices[heap[0]] = 0; + indices[x] = -1; + heap.pop(); + if (heap.size() > 1) percolateDown(0); + return x; + } + + + // Rebuild the heap from scratch, using the elements in 'ns': + void build(const vec& ns) { + for (int i = 0; i < heap.size(); i++) + indices[heap[i]] = -1; + heap.clear(); + + for (int i = 0; i < ns.size(); i++){ + indices[ns[i]] = i; + heap.push(ns[i]); } + + for (int i = heap.size() / 2 - 1; i >= 0; i--) + percolateDown(i); + } + + void clear(bool dealloc = false) + { + for (int i = 0; i < heap.size(); i++) + indices[heap[i]] = -1; + heap.clear(dealloc); + } +}; + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/IntTypes.h b/lstech_maple/lstech/mtl/IntTypes.h new file mode 100755 index 0000000..c488162 --- /dev/null +++ b/lstech_maple/lstech/mtl/IntTypes.h @@ -0,0 +1,42 @@ +/**************************************************************************************[IntTypes.h] +Copyright (c) 2009-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_IntTypes_h +#define Minisat_IntTypes_h + +#ifdef __sun + // Not sure if there are newer versions that support C99 headers. The + // needed features are implemented in the headers below though: + +# include +# include +# include + +#else + +# include +# include + +#endif + +#include + +//================================================================================================= + +#endif diff --git a/lstech_maple/lstech/mtl/Map.h b/lstech_maple/lstech/mtl/Map.h new file mode 100755 index 0000000..8a82d0e --- /dev/null +++ b/lstech_maple/lstech/mtl/Map.h @@ -0,0 +1,193 @@ +/*******************************************************************************************[Map.h] +Copyright (c) 2006-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Map_h +#define Minisat_Map_h + +#include "mtl/IntTypes.h" +#include "mtl/Vec.h" + +namespace Minisat { + +//================================================================================================= +// Default hash/equals functions +// + +template struct Hash { uint32_t operator()(const K& k) const { return hash(k); } }; +template struct Equal { bool operator()(const K& k1, const K& k2) const { return k1 == k2; } }; + +template struct DeepHash { uint32_t operator()(const K* k) const { return hash(*k); } }; +template struct DeepEqual { bool operator()(const K* k1, const K* k2) const { return *k1 == *k2; } }; + +static inline uint32_t hash(uint32_t x){ return x; } +static inline uint32_t hash(uint64_t x){ return (uint32_t)x; } +static inline uint32_t hash(int32_t x) { return (uint32_t)x; } +static inline uint32_t hash(int64_t x) { return (uint32_t)x; } + + +//================================================================================================= +// Some primes +// + +static const int nprimes = 25; +static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 }; + +//================================================================================================= +// Hash table implementation of Maps +// + +template, class E = Equal > +class Map { + public: + struct Pair { K key; D data; }; + + private: + H hash; + E equals; + + vec* table; + int cap; + int size; + + // Don't allow copying (error prone): + Map& operator = (Map& other) { assert(0); } + Map (Map& other) { assert(0); } + + bool checkCap(int new_size) const { return new_size > cap; } + + int32_t index (const K& k) const { return hash(k) % cap; } + void _insert (const K& k, const D& d) { + vec& ps = table[index(k)]; + ps.push(); ps.last().key = k; ps.last().data = d; } + + void rehash () { + const vec* old = table; + + int old_cap = cap; + int newsize = primes[0]; + for (int i = 1; newsize <= cap && i < nprimes; i++) + newsize = primes[i]; + + table = new vec[newsize]; + cap = newsize; + + for (int i = 0; i < old_cap; i++){ + for (int j = 0; j < old[i].size(); j++){ + _insert(old[i][j].key, old[i][j].data); }} + + delete [] old; + + // printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize); + } + + + public: + + Map () : table(NULL), cap(0), size(0) {} + Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){} + ~Map () { delete [] table; } + + // PRECONDITION: the key must already exist in the map. + const D& operator [] (const K& k) const + { + assert(size != 0); + const D* res = NULL; + const vec& ps = table[index(k)]; + for (int i = 0; i < ps.size(); i++) + if (equals(ps[i].key, k)) + res = &ps[i].data; + assert(res != NULL); + return *res; + } + + // PRECONDITION: the key must already exist in the map. + D& operator [] (const K& k) + { + assert(size != 0); + D* res = NULL; + vec& ps = table[index(k)]; + for (int i = 0; i < ps.size(); i++) + if (equals(ps[i].key, k)) + res = &ps[i].data; + assert(res != NULL); + return *res; + } + + // PRECONDITION: the key must *NOT* exist in the map. + void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; } + bool peek (const K& k, D& d) const { + if (size == 0) return false; + const vec& ps = table[index(k)]; + for (int i = 0; i < ps.size(); i++) + if (equals(ps[i].key, k)){ + d = ps[i].data; + return true; } + return false; + } + + bool has (const K& k) const { + if (size == 0) return false; + const vec& ps = table[index(k)]; + for (int i = 0; i < ps.size(); i++) + if (equals(ps[i].key, k)) + return true; + return false; + } + + // PRECONDITION: the key must exist in the map. + void remove(const K& k) { + assert(table != NULL); + vec& ps = table[index(k)]; + int j = 0; + for (; j < ps.size() && !equals(ps[j].key, k); j++); + assert(j < ps.size()); + ps[j] = ps.last(); + ps.pop(); + size--; + } + + void clear () { + cap = size = 0; + delete [] table; + table = NULL; + } + + int elems() const { return size; } + int bucket_count() const { return cap; } + + // NOTE: the hash and equality objects are not moved by this method: + void moveTo(Map& other){ + delete [] other.table; + + other.table = table; + other.cap = cap; + other.size = size; + + table = NULL; + size = cap = 0; + } + + // NOTE: given a bit more time, I could make a more C++-style iterator out of this: + const vec& bucket(int i) const { return table[i]; } +}; + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Queue.h b/lstech_maple/lstech/mtl/Queue.h new file mode 100755 index 0000000..17567d6 --- /dev/null +++ b/lstech_maple/lstech/mtl/Queue.h @@ -0,0 +1,69 @@ +/*****************************************************************************************[Queue.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Queue_h +#define Minisat_Queue_h + +#include "mtl/Vec.h" + +namespace Minisat { + +//================================================================================================= + +template +class Queue { + vec buf; + int first; + int end; + +public: + typedef T Key; + + Queue() : buf(1), first(0), end(0) {} + + void clear (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; } + int size () const { return (end >= first) ? end - first : end - first + buf.size(); } + + const T& operator [] (int index) const { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; } + T& operator [] (int index) { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; } + + T peek () const { assert(first != end); return buf[first]; } + void pop () { assert(first != end); first++; if (first == buf.size()) first = 0; } + void insert(T elem) { // INVARIANT: buf[end] is always unused + buf[end++] = elem; + if (end == buf.size()) end = 0; + if (first == end){ // Resize: + vec tmp((buf.size()*3 + 1) >> 1); + //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0); + int i = 0; + for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j]; + for (int j = 0 ; j < end ; j++) tmp[i++] = buf[j]; + first = 0; + end = buf.size(); + tmp.moveTo(buf); + } + } +}; + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Sort.h b/lstech_maple/lstech/mtl/Sort.h new file mode 100755 index 0000000..e9313ef --- /dev/null +++ b/lstech_maple/lstech/mtl/Sort.h @@ -0,0 +1,98 @@ +/******************************************************************************************[Sort.h] +Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Sort_h +#define Minisat_Sort_h + +#include "mtl/Vec.h" + +//================================================================================================= +// Some sorting algorithms for vec's + + +namespace Minisat { + +template +struct LessThan_default { + bool operator () (T x, T y) { return x < y; } +}; + + +template +void selectionSort(T* array, int size, LessThan lt) +{ + int i, j, best_i; + T tmp; + + for (i = 0; i < size-1; i++){ + best_i = i; + for (j = i+1; j < size; j++){ + if (lt(array[j], array[best_i])) + best_i = j; + } + tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp; + } +} +template static inline void selectionSort(T* array, int size) { + selectionSort(array, size, LessThan_default()); } + +template +void sort(T* array, int size, LessThan lt) +{ + if (size <= 15) + selectionSort(array, size, lt); + + else{ + T pivot = array[size / 2]; + T tmp; + int i = -1; + int j = size; + + for(;;){ + do i++; while(lt(array[i], pivot)); + do j--; while(lt(pivot, array[j])); + + if (i >= j) break; + + tmp = array[i]; array[i] = array[j]; array[j] = tmp; + } + + sort(array , i , lt); + sort(&array[i], size-i, lt); + } +} +template static inline void sort(T* array, int size) { + sort(array, size, LessThan_default()); } + + +//================================================================================================= +// For 'vec's: + + +template void sort(vec& v, LessThan lt) { + sort((T*)v, v.size(), lt); } +template void sort(vec& v) { + sort(v, LessThan_default()); } + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/Vec.h b/lstech_maple/lstech/mtl/Vec.h new file mode 100755 index 0000000..9e22085 --- /dev/null +++ b/lstech_maple/lstech/mtl/Vec.h @@ -0,0 +1,130 @@ +/*******************************************************************************************[Vec.h] +Copyright (c) 2003-2007, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Vec_h +#define Minisat_Vec_h + +#include +#include + +#include "mtl/IntTypes.h" +#include "mtl/XAlloc.h" + +namespace Minisat { + +//================================================================================================= +// Automatically resizable arrays +// +// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc) + +template +class vec { + T* data; + int sz; + int cap; + + // Don't allow copying (error prone): + vec& operator = (vec& other) { assert(0); return *this; } + vec (vec& other) { assert(0); } + + // Helpers for calculating next capacity: + static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); } + //static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } + static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; } + +public: + // Constructors: + vec() : data(NULL) , sz(0) , cap(0) { } + explicit vec(int size) : data(NULL) , sz(0) , cap(0) { growTo(size); } + vec(int size, const T& pad) : data(NULL) , sz(0) , cap(0) { growTo(size, pad); } + ~vec() { clear(true); } + + // Pointer to first element: + operator T* (void) { return data; } + + // Size operations: + int size (void) const { return sz; } + void shrink (int nelems) { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); } + void shrink_ (int nelems) { assert(nelems <= sz); sz -= nelems; } + int capacity (void) const { return cap; } + void capacity (int min_cap); + void growTo (int size); + void growTo (int size, const T& pad); + void clear (bool dealloc = false); + + // Stack interface: + void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; } + void push (const T& elem) { if (sz == cap) capacity(sz+1); data[sz++] = elem; } + void push_ (const T& elem) { assert(sz < cap); data[sz++] = elem; } + void pop (void) { assert(sz > 0); sz--, data[sz].~T(); } + // NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but + // in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not + // happen given the way capacities are calculated (below). Essentially, all capacities are + // even, but INT_MAX is odd. + + const T& last (void) const { return data[sz-1]; } + T& last (void) { return data[sz-1]; } + + // Vector interface: + const T& operator [] (int index) const { return data[index]; } + T& operator [] (int index) { return data[index]; } + + // Duplicatation (preferred instead): + void copyTo(vec& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) copy[i] = data[i]; } + void moveTo(vec& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; } +}; + + +template +void vec::capacity(int min_cap) { + if (cap >= min_cap) return; + int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2 + if (add > INT_MAX - cap || ((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM) + throw OutOfMemoryException(); + } + + +template +void vec::growTo(int size, const T& pad) { + if (sz >= size) return; + capacity(size); + for (int i = sz; i < size; i++) data[i] = pad; + sz = size; } + + +template +void vec::growTo(int size) { + if (sz >= size) return; + capacity(size); + for (int i = sz; i < size; i++) new (&data[i]) T(); + sz = size; } + + +template +void vec::clear(bool dealloc) { + if (data != NULL){ + for (int i = 0; i < sz; i++) data[i].~T(); + sz = 0; + if (dealloc) free(data), data = NULL, cap = 0; } } + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/XAlloc.h b/lstech_maple/lstech/mtl/XAlloc.h new file mode 100755 index 0000000..1da1760 --- /dev/null +++ b/lstech_maple/lstech/mtl/XAlloc.h @@ -0,0 +1,45 @@ +/****************************************************************************************[XAlloc.h] +Copyright (c) 2009-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + + +#ifndef Minisat_XAlloc_h +#define Minisat_XAlloc_h + +#include +#include + +namespace Minisat { + +//================================================================================================= +// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing: + +class OutOfMemoryException{}; +static inline void* xrealloc(void *ptr, size_t size) +{ + void* mem = realloc(ptr, size); + if (mem == NULL && errno == ENOMEM){ + throw OutOfMemoryException(); + }else + return mem; +} + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/mtl/config.mk b/lstech_maple/lstech/mtl/config.mk new file mode 100755 index 0000000..b5c36fc --- /dev/null +++ b/lstech_maple/lstech/mtl/config.mk @@ -0,0 +1,6 @@ +## +## This file is for system specific configurations. For instance, on +## some systems the path to zlib needs to be added. Example: +## +## CFLAGS += -I/usr/local/include +## LFLAGS += -L/usr/local/lib diff --git a/lstech_maple/lstech/mtl/template.mk b/lstech_maple/lstech/mtl/template.mk new file mode 100755 index 0000000..8db220e --- /dev/null +++ b/lstech_maple/lstech/mtl/template.mk @@ -0,0 +1,107 @@ +## +## Template makefile for Standard, Profile, Debug, Release, and Release-static versions +## +## eg: "make rs" for a statically linked release version. +## "make d" for a debug version (no optimizations). +## "make" for the standard version (optimized, but with debug information and assertions active) + +PWD = $(shell pwd) +EXEC ?= $(notdir $(PWD)) + +CSRCS = $(wildcard $(PWD)/*.cc) +DSRCS = $(foreach dir, $(DEPDIR), $(filter-out $(MROOT)/$(dir)/Main.cc, $(wildcard $(MROOT)/$(dir)/*.cc))) +CHDRS = $(wildcard $(PWD)/*.h) +COBJS = $(CSRCS:.cc=.o) $(DSRCS:.cc=.o) + +PCOBJS = $(addsuffix p, $(COBJS)) +DCOBJS = $(addsuffix d, $(COBJS)) +RCOBJS = $(addsuffix r, $(COBJS)) + + +CXX ?= g++ +CFLAGS ?= -Wall -Wno-parentheses -std=c++11 +LFLAGS ?= -Wall + +COPTIMIZE ?= -O3 + +CFLAGS += -I$(MROOT) -D __STDC_LIMIT_MACROS -D __STDC_FORMAT_MACROS +LFLAGS += -lz + +.PHONY : s p d r rs clean + +s: $(EXEC) +p: $(EXEC)_profile +d: $(EXEC)_debug +r: $(EXEC)_release +rs: $(EXEC)_static + +libs: lib$(LIB)_standard.a +libp: lib$(LIB)_profile.a +libd: lib$(LIB)_debug.a +libr: lib$(LIB)_release.a + +## Compile options +%.o: CFLAGS +=$(COPTIMIZE) -g -D DEBUG +%.op: CFLAGS +=$(COPTIMIZE) -pg -g -D NDEBUG +%.od: CFLAGS +=-O0 -g -D DEBUG +%.or: CFLAGS +=$(COPTIMIZE) -g -D NDEBUG + +## Link options +$(EXEC): LFLAGS += -g +$(EXEC)_profile: LFLAGS += -g -pg +$(EXEC)_debug: LFLAGS += -g +#$(EXEC)_release: LFLAGS += ... +$(EXEC)_static: LFLAGS += --static + +## Dependencies +$(EXEC): $(COBJS) +$(EXEC)_profile: $(PCOBJS) +$(EXEC)_debug: $(DCOBJS) +$(EXEC)_release: $(RCOBJS) +$(EXEC)_static: $(RCOBJS) + +lib$(LIB)_standard.a: $(filter-out */Main.o, $(COBJS)) +lib$(LIB)_profile.a: $(filter-out */Main.op, $(PCOBJS)) +lib$(LIB)_debug.a: $(filter-out */Main.od, $(DCOBJS)) +lib$(LIB)_release.a: $(filter-out */Main.or, $(RCOBJS)) + + +## Build rule +%.o %.op %.od %.or: %.cc + @echo Compiling: $(subst $(MROOT)/,,$@) + @$(CXX) $(CFLAGS) -c -o $@ $< + +## Linking rules (standard/profile/debug/release) +$(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static: + @echo Linking: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )" + @$(CXX) $^ $(LFLAGS) -o $@ + +## Library rules (standard/profile/debug/release) +lib$(LIB)_standard.a lib$(LIB)_profile.a lib$(LIB)_release.a lib$(LIB)_debug.a: + @echo Making library: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )" + @$(AR) -rcsv $@ $^ + +## Library Soft Link rule: +libs libp libd libr: + @echo "Making Soft Link: $^ -> lib$(LIB).a" + @ln -sf $^ lib$(LIB).a + +## Clean rule +clean: + @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \ + $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mk + +## Make dependencies +depend.mk: $(CSRCS) $(CHDRS) + @echo Making dependencies + @$(CXX) $(CFLAGS) -I$(MROOT) \ + $(CSRCS) -MM | sed 's|\(.*\):|$(PWD)/\1 $(PWD)/\1r $(PWD)/\1d $(PWD)/\1p:|' > depend.mk + @for dir in $(DEPDIR); do \ + if [ -r $(MROOT)/$${dir}/depend.mk ]; then \ + echo Depends on: $${dir}; \ + cat $(MROOT)/$${dir}/depend.mk >> depend.mk; \ + fi; \ + done + +-include $(MROOT)/mtl/config.mk +-include depend.mk diff --git a/lstech_maple/lstech/simp/Main.cc b/lstech_maple/lstech/simp/Main.cc new file mode 100755 index 0000000..9570e59 --- /dev/null +++ b/lstech_maple/lstech/simp/Main.cc @@ -0,0 +1,266 @@ +/*****************************************************************************************[Main.cc] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + +MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121. + +MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters. + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include + +#include +#include +#include + +#include "utils/System.h" +#include "utils/ParseUtils.h" +#include "utils/Options.h" +#include "core/Dimacs.h" +#include "simp/SimpSolver.h" + +using namespace Minisat; + +//================================================================================================= + + +void printStats(Solver& solver) +{ + double cpu_time = cpuTime(); + double mem_used = memUsedPeak(); + printf("c restarts : %"PRIu64"\n", solver.starts); + printf("c duplicate learnts_cnf : %"PRIu64"\n", solver.duplicates_added_conflicts); + printf("c duplicate learnts_min : %"PRIu64"\n", solver.duplicates_added_minimization); + printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time); + printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time); + printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time); + printf("c conflict literals : %-12"PRIu64" (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals); + printf("c backtracks : %-12"PRIu64" (NCB %0.f%% , CB %0.f%%)\n", solver.non_chrono_backtrack + solver.chrono_backtrack, (solver.non_chrono_backtrack * 100) / (double)(solver.non_chrono_backtrack + solver.chrono_backtrack), (solver.chrono_backtrack * 100) / (double)(solver.non_chrono_backtrack + solver.chrono_backtrack)); + if (mem_used != 0) printf("c Memory used : %.2f MB\n", mem_used); + printf("c CPU time : %g s\n", cpu_time); +} + + +static Solver* solver; +// Terminate by notifying the solver and back out gracefully. This is mainly to have a test-case +// for this feature of the Solver as it may take longer than an immediate call to '_exit()'. +static void SIGINT_interrupt(int signum) { solver->interrupt(); } + +// Note that '_exit()' rather than 'exit()' has to be used. The reason is that 'exit()' calls +// destructors and may cause deadlocks if a malloc/free function happens to be running (these +// functions are guarded by locks for multithreaded use). +static void SIGINT_exit(int signum) { + printf("\n"); printf("c *** INTERRUPTED ***\n"); + if (solver->verbosity > 0){ + printStats(*solver); + printf("\n"); printf("c *** INTERRUPTED ***\n"); } + _exit(1); } + + +//================================================================================================= +// Main: + +int main(int argc, char** argv) +{ + try { + setUsageHelp("USAGE: %s [options] \n\n where input may be either in plain or gzipped DIMACS.\n"); + printf("c This is MapleLCMDistChronoBT-DL.\n"); + +#if defined(__linux__) + fpu_control_t oldcw, newcw; + _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw); + printf("c WARNING: for repeatability, setting FPU to use double precision\n"); +#endif + // Extra options: + // + IntOption verb ("MAIN", "verb", "Verbosity level (0=silent, 1=some, 2=more).", 1, IntRange(0, 2)); + BoolOption pre ("MAIN", "pre", "Completely turn on/off any preprocessing.", true); + StringOption dimacs ("MAIN", "dimacs", "If given, stop after preprocessing and write the result to this file."); + IntOption cpu_lim("MAIN", "cpu-lim","Limit on CPU time allowed in seconds.\n", INT32_MAX, IntRange(0, INT32_MAX)); + IntOption mem_lim("MAIN", "mem-lim","Limit on memory usage in megabytes.\n", INT32_MAX, IntRange(0, INT32_MAX)); + BoolOption drup ("MAIN", "drup", "Generate DRUP UNSAT proof.", false); + StringOption drup_file("MAIN", "drup-file", "DRUP UNSAT proof ouput file.", ""); + + parseOptions(argc, argv, true); + + SimpSolver S; + double initial_time = cpuTime(); + + if (!pre) S.eliminate(true); + + S.parsing = true; + S.verbosity = verb; + S.drup_file = NULL; + if (drup || strlen(drup_file)){ + S.drup_file = strlen(drup_file) ? fopen(drup_file, "wb") : stdout; + if (S.drup_file == NULL){ + S.drup_file = stdout; + printf("c Error opening %s for write.\n", (const char*) drup_file); } + printf("c DRUP proof generation: %s\n", S.drup_file == stdout ? "stdout" : drup_file); + } + + solver = &S; + // Use signal handlers that forcibly quit until the solver will be able to respond to + // interrupts: + signal(SIGINT, SIGINT_exit); + signal(SIGXCPU,SIGINT_exit); + + // Set limit on CPU-time: + if (cpu_lim != INT32_MAX){ + rlimit rl; + getrlimit(RLIMIT_CPU, &rl); + if (rl.rlim_max == RLIM_INFINITY || (rlim_t)cpu_lim < rl.rlim_max){ + rl.rlim_cur = cpu_lim; + if (setrlimit(RLIMIT_CPU, &rl) == -1) + printf("c WARNING! Could not set resource limit: CPU-time.\n"); + } } + + // Set limit on virtual memory: + if (mem_lim != INT32_MAX){ + rlim_t new_mem_lim = (rlim_t)mem_lim * 1024*1024; + rlimit rl; + getrlimit(RLIMIT_AS, &rl); + if (rl.rlim_max == RLIM_INFINITY || new_mem_lim < rl.rlim_max){ + rl.rlim_cur = new_mem_lim; + if (setrlimit(RLIMIT_AS, &rl) == -1) + printf("c WARNING! Could not set resource limit: Virtual memory.\n"); + } } + + if (argc == 1) + printf("c Reading from standard input... Use '--help' for help.\n"); + + gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb"); + if (in == NULL) + printf("c ERROR! Could not open file: %s\n", argc == 1 ? "" : argv[1]), exit(1); + + if (S.verbosity > 0){ + printf("c ============================[ Problem Statistics ]=============================\n"); + printf("c | |\n"); } + + parse_DIMACS(in, S); + gzclose(in); + FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL; + + if (S.verbosity > 0){ + printf("c | Number of variables: %12d |\n", S.nVars()); + printf("c | Number of clauses: %12d |\n", S.nClauses()); } + + double parsed_time = cpuTime(); + if (S.verbosity > 0) + printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time); + + // Change to signal-handlers that will only notify the solver and allow it to terminate + // voluntarily: + signal(SIGINT, SIGINT_interrupt); + signal(SIGXCPU,SIGINT_interrupt); + + S.parsing = false; + S.eliminate(true); + double simplified_time = cpuTime(); + if (S.verbosity > 0){ + printf("c | Simplification time: %12.2f s |\n", simplified_time - parsed_time); + printf("c | |\n"); } + + if (!S.okay()){ + if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res); + if (S.verbosity > 0){ + printf("c ===============================================================================\n"); + printf("c Solved by simplification\n"); + printStats(S); + printf("\n"); } + printf("s UNSATISFIABLE\n"); + if (S.drup_file){ +#ifdef BIN_DRUP + fputc('a', S.drup_file); fputc(0, S.drup_file); +#else + fprintf(S.drup_file, "0\n"); +#endif + } + if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file); + exit(20); + } + + if (dimacs){ + if (S.verbosity > 0) + printf("c ==============================[ Writing DIMACS ]===============================\n"); + S.toDimacs((const char*)dimacs); + if (S.verbosity > 0) + printStats(S); + exit(0); + } + + vec dummy; + lbool ret = S.solveLimited(dummy); + + if (S.verbosity > 0){ + printStats(S); + printf("\n"); } + printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n"); + if (ret == l_True){ + // check_solution_DIMACS(in, S); + // printf("%d",S.nVars()); + printf("v "); + for (int i = 0; i < S.nVars(); i++) + if (S.model[i] != l_Undef) + printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); + printf(" 0\n"); + } + + + if (S.drup_file && ret == l_False){ +#ifdef BIN_DRUP + fputc('a', S.drup_file); fputc(0, S.drup_file); +#else + fprintf(S.drup_file, "0\n"); +#endif + } + if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file); + + if (res != NULL){ + if (ret == l_True){ + fprintf(res, "SAT\n"); + for (int i = 0; i < S.nVars(); i++) + if (S.model[i] != l_Undef) + fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1); + fprintf(res, " 0\n"); + }else if (ret == l_False) + fprintf(res, "UNSAT\n"); + else + fprintf(res, "INDET\n"); + fclose(res); + } + +#ifdef NDEBUG + exit(ret == l_True ? 10 : ret == l_False ? 20 : 0); // (faster than "return", which will invoke the destructor for 'Solver') +#else + return (ret == l_True ? 10 : ret == l_False ? 20 : 0); +#endif + } catch (OutOfMemoryException&){ + printf("c ===============================================================================\n"); + printf("c Out of memory\n"); + printf("s UNKNOWN\n"); + exit(0); + } +} diff --git a/lstech_maple/lstech/simp/Main.or b/lstech_maple/lstech/simp/Main.or new file mode 100755 index 0000000..d7c03e5 Binary files /dev/null and b/lstech_maple/lstech/simp/Main.or differ diff --git a/lstech_maple/lstech/simp/Makefile b/lstech_maple/lstech/simp/Makefile new file mode 100755 index 0000000..0004de8 --- /dev/null +++ b/lstech_maple/lstech/simp/Makefile @@ -0,0 +1,5 @@ +EXEC = glucose +DEPDIR = mtl utils core +MROOT = ../ + +include $(MROOT)/mtl/template.mk diff --git a/lstech_maple/lstech/simp/SimpSolver.cc b/lstech_maple/lstech/simp/SimpSolver.cc new file mode 100755 index 0000000..15c4c7a --- /dev/null +++ b/lstech_maple/lstech/simp/SimpSolver.cc @@ -0,0 +1,921 @@ +/***************************************************************************************[Solver.cc] +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + +MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121. + +MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters. + +lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang +Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT. +Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing. + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include "mtl/Sort.h" +#include "simp/SimpSolver.h" +#include "utils/System.h" + +using namespace Minisat; + +//================================================================================================= +// Options: + + +static const char* _cat = "SIMP"; + +static BoolOption opt_use_asymm (_cat, "asymm", "Shrink clauses by asymmetric branching.", false); +static BoolOption opt_use_rcheck (_cat, "rcheck", "Check if a clause is already implied. (costly)", false); +static BoolOption opt_use_elim (_cat, "elim", "Perform variable elimination.", true); +static IntOption opt_grow (_cat, "grow", "Allow a variable elimination step to grow by a number of clauses.", 0); +static IntOption opt_clause_lim (_cat, "cl-lim", "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20, IntRange(-1, INT32_MAX)); +static IntOption opt_subsumption_lim (_cat, "sub-lim", "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX)); +static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.", 0.5, DoubleRange(0, false, HUGE_VAL, false)); + + +//================================================================================================= +// Constructor/Destructor: + + +SimpSolver::SimpSolver() : + parsing (false) + , grow (opt_grow) + , clause_lim (opt_clause_lim) + , subsumption_lim (opt_subsumption_lim) + , simp_garbage_frac (opt_simp_garbage_frac) + , use_asymm (opt_use_asymm) + , use_rcheck (opt_use_rcheck) + , use_elim (opt_use_elim) + , merges (0) + , asymm_lits (0) + , eliminated_vars (0) + , elimorder (1) + , use_simplification (true) + , occurs (ClauseDeleted(ca)) + , elim_heap (ElimLt(n_occ)) + , bwdsub_assigns (0) + , n_touched (0) +{ + vec dummy(1,lit_Undef); + ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below. + bwdsub_tmpunit = ca.alloc(dummy); + remove_satisfied = false; +} + + +SimpSolver::~SimpSolver() +{ +} + +void SimpSolver::varGrowTo(int maxVar) { + for (int v = 0; v < maxVar; v++) { + watches_bin.init(mkLit(v, false)); + watches_bin.init(mkLit(v, true )); + watches .init(mkLit(v, false)); + watches .init(mkLit(v, true )); + assigns .push(l_Undef); + vardata .push(mkVarData(CRef_Undef, 0)); + activity_CHB .push(0); + activity_VSIDS.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0); + + picked.push(0); + conflicted.push(0); + almost_conflicted.push(0); + #ifdef ANTI_EXPLORATION + canceled.push(0); + #endif + seen .push(0); + seen2 .push(0); + polarity .push(true); + decision .push(); + trail .capacity(v+1); + + frozen .push((char)false); + eliminated.push((char)false); + + if (use_simplification){ + n_occ .push(0); + n_occ .push(0); + occurs .init(v); + touched .push(0); + elim_heap .insert(v); + } + } + + int seed = worker_seed; + int index = worker_index; + int number = worker_number; + if (seed != -1) { + int *id; + id = (int *)malloc(sizeof(int) * (maxVar)); + for (int i = 0; i < maxVar; i++) id[i] = i; + if (seed) { + unsigned int rseed = seed; + for (int i = 0; i < maxVar; i++) { + int j = rand_r(&rseed) % maxVar; + int x = id[i]; + id[i] = id[j]; + id[j] = x; + } + } + int block_size = maxVar / number; + int cursor = index * block_size; + for (int v = cursor; v < maxVar; v++) { + setDecisionVar(id[v], true); + } + for (int v = 0; v < cursor; v++) { + setDecisionVar(id[v], true); + } + // printf("c maxVar %d, index:%d number:%d seed:%d\n", maxVar, index, number, seed); + // for (int v = cursor; v < maxVar; v++) { + // printf("%d ", id[v]); + // } + // for (int v = 0; v < cursor; v++) { + // printf("%d ", id[v]); + // } + // puts(""); + free(id); + } + else { + for (int v = 0; v < maxVar; v++) { + setDecisionVar(v, true); + } + // printf("c maxVar %d, index:%d number:%d seed:%d\n", maxVar, index, number, seed); + // for (int v = 0; v < maxVar; v++) { + // printf("%d ", v); + // } + // puts(""); + } +} + + + +Var SimpSolver::newVar(bool sign, bool dvar) { + Var v = Solver::newVar(sign, dvar); + + frozen .push((char)false); + eliminated.push((char)false); + + if (use_simplification){ + n_occ .push(0); + n_occ .push(0); + occurs .init(v); + touched .push(0); + elim_heap .insert(v); + } + return v; } + + + +lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp) +{ + vec extra_frozen; + lbool result = l_True; + + do_simp &= use_simplification; + + if (do_simp){ + // Assumptions must be temporarily frozen to run variable elimination: + for (int i = 0; i < assumptions.size(); i++){ + Var v = var(assumptions[i]); + + // If an assumption has been eliminated, remember it. + assert(!isEliminated(v)); + + if (!frozen[v]){ + // Freeze and store. + setFrozen(v, true); + extra_frozen.push(v); + } } + + result = lbool(eliminate(turn_off_simp)); + } + + if (result == l_True) + result = Solver::solve_(); + else if (verbosity >= 1) + printf("c ===============================================================================\n"); + + if (result == l_True) + extendModel(); + + if (do_simp) + // Unfreeze the assumptions that were frozen: + for (int i = 0; i < extra_frozen.size(); i++) + setFrozen(extra_frozen[i], false); + + return result; +} + + + +bool SimpSolver::addClause_(vec& ps) +{ +#ifndef NDEBUG + for (int i = 0; i < ps.size(); i++) + assert(!isEliminated(var(ps[i]))); +#endif + + int nclauses = clauses.size(); + + if (use_rcheck && implied(ps)) + return true; + + if (!Solver::addClause_(ps)) + return false; + + if (!parsing && drup_file) { +#ifdef BIN_DRUP + binDRUP('a', ps, drup_file); +#else + for (int i = 0; i < ps.size(); i++) + fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + } + + if (use_simplification && clauses.size() == nclauses + 1){ + CRef cr = clauses.last(); + const Clause& c = ca[cr]; + + // NOTE: the clause is added to the queue immediately and then + // again during 'gatherTouchedClauses()'. If nothing happens + // in between, it will only be checked once. Otherwise, it may + // be checked twice unnecessarily. This is an unfortunate + // consequence of how backward subsumption is used to mimic + // forward subsumption. + subsumption_queue.insert(cr); + for (int i = 0; i < c.size(); i++){ + occurs[var(c[i])].push(cr); + n_occ[toInt(c[i])]++; + touched[var(c[i])] = 1; + n_touched++; + if (elim_heap.inHeap(var(c[i]))) + elim_heap.increase(var(c[i])); + } + } + + return true; +} + + +void SimpSolver::removeClause(CRef cr) +{ + const Clause& c = ca[cr]; + + if (use_simplification) + for (int i = 0; i < c.size(); i++){ + n_occ[toInt(c[i])]--; + updateElimHeap(var(c[i])); + occurs.smudge(var(c[i])); + } + + Solver::removeClause(cr); +} + + +bool SimpSolver::strengthenClause(CRef cr, Lit l) +{ + Clause& c = ca[cr]; + assert(decisionLevel() == 0); + assert(use_simplification); + + // FIX: this is too inefficient but would be nice to have (properly implemented) + // if (!find(subsumption_queue, &c)) + subsumption_queue.insert(cr); + + if (drup_file){ +#ifdef BIN_DRUP + binDRUP_strengthen(c, l, drup_file); +#else + for (int i = 0; i < c.size(); i++) + if (c[i] != l) fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + } + + if (c.size() == 2){ + removeClause(cr); + c.strengthen(l); + }else{ + if (drup_file){ +#ifdef BIN_DRUP + binDRUP('d', c, drup_file); +#else + fprintf(drup_file, "d "); + for (int i = 0; i < c.size(); i++) + fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1)); + fprintf(drup_file, "0\n"); +#endif + } + + detachClause(cr, true); + c.strengthen(l); + attachClause(cr); + remove(occurs[var(l)], cr); + n_occ[toInt(l)]--; + updateElimHeap(var(l)); + } + + return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true; +} + + +// Returns FALSE if clause is always satisfied ('out_clause' should not be used). +bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec& out_clause) +{ + merges++; + out_clause.clear(); + + bool ps_smallest = _ps.size() < _qs.size(); + const Clause& ps = ps_smallest ? _qs : _ps; + const Clause& qs = ps_smallest ? _ps : _qs; + + for (int i = 0; i < qs.size(); i++){ + if (var(qs[i]) != v){ + for (int j = 0; j < ps.size(); j++) + if (var(ps[j]) == var(qs[i])) + if (ps[j] == ~qs[i]) + return false; + else + goto next; + out_clause.push(qs[i]); + } + next:; + } + + for (int i = 0; i < ps.size(); i++) + if (var(ps[i]) != v) + out_clause.push(ps[i]); + + return true; +} + + +// Returns FALSE if clause is always satisfied. +bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size) +{ + merges++; + + bool ps_smallest = _ps.size() < _qs.size(); + const Clause& ps = ps_smallest ? _qs : _ps; + const Clause& qs = ps_smallest ? _ps : _qs; + const Lit* __ps = (const Lit*)ps; + const Lit* __qs = (const Lit*)qs; + + size = ps.size()-1; + + for (int i = 0; i < qs.size(); i++){ + if (var(__qs[i]) != v){ + for (int j = 0; j < ps.size(); j++) + if (var(__ps[j]) == var(__qs[i])) + if (__ps[j] == ~__qs[i]) + return false; + else + goto next; + size++; + } + next:; + } + + return true; +} + + +void SimpSolver::gatherTouchedClauses() +{ + if (n_touched == 0) return; + + int i,j; + for (i = j = 0; i < subsumption_queue.size(); i++) + if (ca[subsumption_queue[i]].mark() == 0) + ca[subsumption_queue[i]].mark(2); + + for (i = 0; i < touched.size(); i++) + if (touched[i]){ + const vec& cs = occurs.lookup(i); + for (j = 0; j < cs.size(); j++) + if (ca[cs[j]].mark() == 0){ + subsumption_queue.insert(cs[j]); + ca[cs[j]].mark(2); + } + touched[i] = 0; + } + + for (i = 0; i < subsumption_queue.size(); i++) + if (ca[subsumption_queue[i]].mark() == 2) + ca[subsumption_queue[i]].mark(0); + + n_touched = 0; +} + + +bool SimpSolver::implied(const vec& c) +{ + assert(decisionLevel() == 0); + + trail_lim.push(trail.size()); + for (int i = 0; i < c.size(); i++) + if (value(c[i]) == l_True){ + cancelUntil(0); + return true; + }else if (value(c[i]) != l_False){ + assert(value(c[i]) == l_Undef); + uncheckedEnqueue(~c[i]); + } + + bool result = propagate() != CRef_Undef; + cancelUntil(0); + return result; +} + + +// Backward subsumption + backward subsumption resolution +bool SimpSolver::backwardSubsumptionCheck(bool verbose) +{ + int cnt = 0; + int subsumed = 0; + int deleted_literals = 0; + assert(decisionLevel() == 0); + + while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){ + + // Empty subsumption queue and return immediately on user-interrupt: + if (asynch_interrupt){ + subsumption_queue.clear(); + bwdsub_assigns = trail.size(); + break; } + + // Check top-level assignments by creating a dummy clause and placing it in the queue: + if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){ + Lit l = trail[bwdsub_assigns++]; + ca[bwdsub_tmpunit][0] = l; + ca[bwdsub_tmpunit].calcAbstraction(); + subsumption_queue.insert(bwdsub_tmpunit); } + + CRef cr = subsumption_queue.peek(); subsumption_queue.pop(); + Clause& c = ca[cr]; + + if (c.mark()) continue; + + if (verbose && verbosity >= 2 && cnt++ % 1000 == 0) + printf("c subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals); + + assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point. + + // Find best variable to scan: + Var best = var(c[0]); + for (int i = 1; i < c.size(); i++) + if (occurs[var(c[i])].size() < occurs[best].size()) + best = var(c[i]); + + // Search all candidates: + vec& _cs = occurs.lookup(best); + CRef* cs = (CRef*)_cs; + + for (int j = 0; j < _cs.size(); j++) + if (c.mark()) + break; + else if (!ca[cs[j]].mark() && cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){ + Lit l = c.subsumes(ca[cs[j]]); + + if (l == lit_Undef) + subsumed++, removeClause(cs[j]); + else if (l != lit_Error){ + deleted_literals++; + + if (!strengthenClause(cs[j], ~l)) + return false; + + // Did current candidate get deleted from cs? Then check candidate at index j again: + if (var(l) == best) + j--; + } + } + } + + return true; +} + + +bool SimpSolver::asymm(Var v, CRef cr) +{ + Clause& c = ca[cr]; + assert(decisionLevel() == 0); + + if (c.mark() || satisfied(c)) return true; + + trail_lim.push(trail.size()); + Lit l = lit_Undef; + for (int i = 0; i < c.size(); i++) + if (var(c[i]) != v){ + if (value(c[i]) != l_False) + uncheckedEnqueue(~c[i]); + }else + l = c[i]; + + if (propagate() != CRef_Undef){ + cancelUntil(0); + asymm_lits++; + if (!strengthenClause(cr, l)) + return false; + }else + cancelUntil(0); + + return true; +} + + +bool SimpSolver::asymmVar(Var v) +{ + assert(use_simplification); + + const vec& cls = occurs.lookup(v); + + if (value(v) != l_Undef || cls.size() == 0) + return true; + + for (int i = 0; i < cls.size(); i++) + if (!asymm(v, cls[i])) + return false; + + return backwardSubsumptionCheck(); +} + + +static void mkElimClause(vec& elimclauses, Lit x) +{ + elimclauses.push(toInt(x)); + elimclauses.push(1); +} + + +static void mkElimClause(vec& elimclauses, Var v, Clause& c) +{ + int first = elimclauses.size(); + int v_pos = -1; + + // Copy clause to elimclauses-vector. Remember position where the + // variable 'v' occurs: + for (int i = 0; i < c.size(); i++){ + elimclauses.push(toInt(c[i])); + if (var(c[i]) == v) + v_pos = i + first; + } + assert(v_pos != -1); + + // Swap the first literal with the 'v' literal, so that the literal + // containing 'v' will occur first in the clause: + uint32_t tmp = elimclauses[v_pos]; + elimclauses[v_pos] = elimclauses[first]; + elimclauses[first] = tmp; + + // Store the length of the clause last: + elimclauses.push(c.size()); +} + + + +bool SimpSolver::eliminateVar(Var v) +{ + assert(!frozen[v]); + assert(!isEliminated(v)); + assert(value(v) == l_Undef); + + // Split the occurrences into positive and negative: + // + const vec& cls = occurs.lookup(v); + vec pos, neg; + for (int i = 0; i < cls.size(); i++) + (find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]); + + // Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no + // clause must exceed the limit on the maximal clause size (if it is set): + // + int cnt = 0; + int clause_size = 0; + + for (int i = 0; i < pos.size(); i++) + for (int j = 0; j < neg.size(); j++) + if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) && + (++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim))) + return true; + + // Delete and store old clauses: + eliminated[v] = true; + setDecisionVar(v, false); + eliminated_vars++; + + if (pos.size() > neg.size()){ + for (int i = 0; i < neg.size(); i++) + mkElimClause(elimclauses, v, ca[neg[i]]); + mkElimClause(elimclauses, mkLit(v)); + }else{ + for (int i = 0; i < pos.size(); i++) + mkElimClause(elimclauses, v, ca[pos[i]]); + mkElimClause(elimclauses, ~mkLit(v)); + } + + // Produce clauses in cross product: + vec& resolvent = add_tmp; + for (int i = 0; i < pos.size(); i++) + for (int j = 0; j < neg.size(); j++) + if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent)) + return false; + + for (int i = 0; i < cls.size(); i++) + removeClause(cls[i]); + + // Free occurs list for this variable: + occurs[v].clear(true); + + // Free watchers lists for this variable, if possible: + watches_bin[ mkLit(v)].clear(true); + watches_bin[~mkLit(v)].clear(true); + watches[ mkLit(v)].clear(true); + watches[~mkLit(v)].clear(true); + + return backwardSubsumptionCheck(); +} + + +bool SimpSolver::substitute(Var v, Lit x) +{ + assert(!frozen[v]); + assert(!isEliminated(v)); + assert(value(v) == l_Undef); + + if (!ok) return false; + + eliminated[v] = true; + setDecisionVar(v, false); + const vec& cls = occurs.lookup(v); + + vec& subst_clause = add_tmp; + for (int i = 0; i < cls.size(); i++){ + Clause& c = ca[cls[i]]; + + subst_clause.clear(); + for (int j = 0; j < c.size(); j++){ + Lit p = c[j]; + subst_clause.push(var(p) == v ? x ^ sign(p) : p); + } + + if (!addClause_(subst_clause)) + return ok = false; + + removeClause(cls[i]); + } + + return true; +} + + +void SimpSolver::extendModel() +{ + int i, j; + Lit x; + + for (i = elimclauses.size()-1; i > 0; i -= j){ + for (j = elimclauses[i--]; j > 1; j--, i--) + if (modelValue(toLit(elimclauses[i])) != l_False) + goto next; + + x = toLit(elimclauses[i]); + model[var(x)] = lbool(!sign(x)); + next:; + } +} + +// Almost duplicate of Solver::removeSatisfied. Didn't want to make the base method 'virtual'. +void SimpSolver::removeSatisfied() +{ + int i, j; + for (i = j = 0; i < clauses.size(); i++){ + const Clause& c = ca[clauses[i]]; + if (c.mark() == 0) + if (satisfied(c)) + removeClause(clauses[i]); + else + clauses[j++] = clauses[i]; + } + clauses.shrink(i - j); +} + +// The technique and code are by the courtesy of the GlueMiniSat team. Thank you! +// It helps solving certain types of huge problems tremendously. +bool SimpSolver::eliminate(bool turn_off_elim) +{ + bool res = true; + int iter = 0; + int n_cls, n_cls_init, n_vars; + + if (nVars() == 0) goto cleanup; // User disabling preprocessing. + + // Get an initial number of clauses (more accurately). + if (trail.size() != 0) removeSatisfied(); + n_cls_init = nClauses(); + + res = eliminate_(); // The first, usual variable elimination of MiniSat. + if (!res) goto cleanup; + + n_cls = nClauses(); + n_vars = nFreeVars(); + + //printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars, n_cls, grow); + + if ((double)n_cls / n_vars >= 10 || n_vars < 10000){ + //printf("c No iterative elimination performed. (vars=%d, c/v ratio=%.1f)\n", n_vars, (double)n_cls / n_vars); + goto cleanup; } + + grow = grow ? grow * 2 : 8; + for (; grow < 10000; grow *= 2){ + // Rebuild elimination variable heap. + for (int i = 0; i < clauses.size(); i++){ + const Clause& c = ca[clauses[i]]; + for (int j = 0; j < c.size(); j++) + if (!elim_heap.inHeap(var(c[j]))) + elim_heap.insert(var(c[j])); + else + elim_heap.update(var(c[j])); } + + int n_cls_last = nClauses(); + int n_vars_last = nFreeVars(); + + res = eliminate_(); + if (!res || n_vars_last == nFreeVars()) break; + iter++; + + int n_cls_now = nClauses(); + int n_vars_now = nFreeVars(); + + double cl_inc_rate = (double)n_cls_now / n_cls_last; + double var_dec_rate = (double)n_vars_last / n_vars_now; + + //printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars_now, n_cls_now, grow); + //printf("c cl_inc_rate=%.3f, var_dec_rate=%.3f\n", cl_inc_rate, var_dec_rate); + + if (n_cls_now > n_cls_init || cl_inc_rate > var_dec_rate) break; + } + //printf("c No. effective iterative eliminations: %d\n", iter); + +cleanup: + touched .clear(true); + occurs .clear(true); + n_occ .clear(true); + elim_heap.clear(true); + subsumption_queue.clear(true); + + use_simplification = false; + remove_satisfied = true; + ca.extra_clause_field = false; + + // Force full cleanup (this is safe and desirable since it only happens once): + rebuildOrderHeap(); + garbageCollect(); + + return res; +} + + +bool SimpSolver::eliminate_() +{ + if (!simplify()) + return false; + else if (!use_simplification) + return true; + + int trail_size_last = trail.size(); + + // Main simplification loop: + // + while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0){ + + gatherTouchedClauses(); + // printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns); + if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) && + !backwardSubsumptionCheck(true)){ + ok = false; goto cleanup; } + + // Empty elim_heap and return immediately on user-interrupt: + if (asynch_interrupt){ + assert(bwdsub_assigns == trail.size()); + assert(subsumption_queue.size() == 0); + assert(n_touched == 0); + elim_heap.clear(); + goto cleanup; } + + // printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size()); + for (int cnt = 0; !elim_heap.empty(); cnt++){ + Var elim = elim_heap.removeMin(); + + if (asynch_interrupt) break; + + if (isEliminated(elim) || value(elim) != l_Undef) continue; + + if (verbosity >= 2 && cnt % 100 == 0) + printf("c elimination left: %10d\r", elim_heap.size()); + + if (use_asymm){ + // Temporarily freeze variable. Otherwise, it would immediately end up on the queue again: + bool was_frozen = frozen[elim]; + frozen[elim] = true; + if (!asymmVar(elim)){ + ok = false; goto cleanup; } + frozen[elim] = was_frozen; } + + // At this point, the variable may have been set by assymetric branching, so check it + // again. Also, don't eliminate frozen variables: + if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){ + ok = false; goto cleanup; } + + checkGarbage(simp_garbage_frac); + } + + assert(subsumption_queue.size() == 0); + } + cleanup: + // To get an accurate number of clauses. + if (trail_size_last != trail.size()) + removeSatisfied(); + else{ + int i,j; + for (i = j = 0; i < clauses.size(); i++) + if (ca[clauses[i]].mark() == 0) + clauses[j++] = clauses[i]; + clauses.shrink(i - j); + } + checkGarbage(); + + if (verbosity >= 1 && elimclauses.size() > 0) + printf("c | Eliminated clauses: %10.2f Mb |\n", + double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024)); + + return ok; +} + + +//================================================================================================= +// Garbage Collection methods: + + +void SimpSolver::relocAll(ClauseAllocator& to) +{ + if (!use_simplification) return; + + // All occurs lists: + // + occurs.cleanAll(); + for (int i = 0; i < nVars(); i++){ + vec& cs = occurs[i]; + for (int j = 0; j < cs.size(); j++) + ca.reloc(cs[j], to); + } + + // Subsumption queue: + // + for (int i = 0; i < subsumption_queue.size(); i++) + ca.reloc(subsumption_queue[i], to); + + // Temporary clause: + // + ca.reloc(bwdsub_tmpunit, to); +} + + +void SimpSolver::garbageCollect() +{ + // Initialize the next region to a size corresponding to the estimated utilization degree. This + // is not precise but should avoid some unnecessary reallocations for the new region: + ClauseAllocator to(ca.size() - ca.wasted()); + + to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields. + relocAll(to); + Solver::relocAll(to); + if (verbosity >= 2) + printf("c | Garbage collection: %12d bytes => %12d bytes |\n", + ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size); + to.moveTo(ca); +} diff --git a/lstech_maple/lstech/simp/SimpSolver.h b/lstech_maple/lstech/simp/SimpSolver.h new file mode 100755 index 0000000..4d4576d --- /dev/null +++ b/lstech_maple/lstech/simp/SimpSolver.h @@ -0,0 +1,216 @@ +/***************************************************************************************[Solver.cc] +MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson + Copyright (c) 2007-2010, Niklas Sorensson + +Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh + +Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach +Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear. + +Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search + +MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121. + +MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters. + +lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang +Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT. +Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing. + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_SimpSolver_h +#define Minisat_SimpSolver_h + +#include "mtl/Queue.h" +#include "core/Solver.h" + + +namespace Minisat { + +//================================================================================================= + + +class SimpSolver : public Solver { + public: + // Constructor/Destructor: + // + SimpSolver(); + ~SimpSolver(); + + // Problem specification: + // + void varGrowTo (int maxVar); + Var newVar (bool polarity = true, bool dvar = true); + bool addClause (const vec& ps); + bool addEmptyClause(); // Add the empty clause to the solver. + bool addClause (Lit p); // Add a unit clause to the solver. + bool addClause (Lit p, Lit q); // Add a binary clause to the solver. + bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver. + bool addClause_( vec& ps); + bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction). + + // Variable mode: + // + void setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated. + bool isEliminated(Var v) const; + + // Solving: + // + bool solve (const vec& assumps, bool do_simp = true, bool turn_off_simp = false); + lbool solveLimited(const vec& assumps, bool do_simp = true, bool turn_off_simp = false); + bool solve ( bool do_simp = true, bool turn_off_simp = false); + bool solve (Lit p , bool do_simp = true, bool turn_off_simp = false); + bool solve (Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false); + bool solve (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false); + bool eliminate (bool turn_off_elim = false); // Perform variable elimination based simplification. + bool eliminate_ (); + void removeSatisfied(); + + // Memory managment: + // + virtual void garbageCollect(); + + + // Generate a (possibly simplified) DIMACS file: + // +#if 0 + void toDimacs (const char* file, const vec& assumps); + void toDimacs (const char* file); + void toDimacs (const char* file, Lit p); + void toDimacs (const char* file, Lit p, Lit q); + void toDimacs (const char* file, Lit p, Lit q, Lit r); +#endif + + // Mode of operation: + // + bool parsing; + int grow; // Allow a variable elimination step to grow by a number of clauses (default to zero). + int clause_lim; // Variables are not eliminated if it produces a resolvent with a length above this limit. + // -1 means no limit. + int subsumption_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit. + double simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac'). + + bool use_asymm; // Shrink clauses by asymmetric branching. + bool use_rcheck; // Check if a clause is already implied. Prett costly, and subsumes subsumptions :) + bool use_elim; // Perform variable elimination. + + // Statistics: + // + int merges; + int asymm_lits; + int eliminated_vars; + + protected: + + // Helper structures: + // + struct ElimLt { + const vec& n_occ; + explicit ElimLt(const vec& no) : n_occ(no) {} + + // TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating + // 32-bit implementation instead then, but this will have to do for now. + uint64_t cost (Var x) const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; } + bool operator()(Var x, Var y) const { return cost(x) < cost(y); } + + // TODO: investigate this order alternative more. + // bool operator()(Var x, Var y) const { + // int c_x = cost(x); + // int c_y = cost(y); + // return c_x < c_y || c_x == c_y && x < y; } + }; + + struct ClauseDeleted { + const ClauseAllocator& ca; + explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {} + bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } }; + + // Solver state: + // + int elimorder; + bool use_simplification; + vec elimclauses; + vec touched; + OccLists, ClauseDeleted> + occurs; + vec n_occ; + Heap elim_heap; + Queue subsumption_queue; + vec frozen; + vec eliminated; + int bwdsub_assigns; + int n_touched; + + // Temporaries: + // + CRef bwdsub_tmpunit; + + // Main internal methods: + // + lbool solve_ (bool do_simp = true, bool turn_off_simp = false); + bool asymm (Var v, CRef cr); + bool asymmVar (Var v); + void updateElimHeap (Var v); + void gatherTouchedClauses (); + bool merge (const Clause& _ps, const Clause& _qs, Var v, vec& out_clause); + bool merge (const Clause& _ps, const Clause& _qs, Var v, int& size); + bool backwardSubsumptionCheck (bool verbose = false); + bool eliminateVar (Var v); + void extendModel (); + + void removeClause (CRef cr); + bool strengthenClause (CRef cr, Lit l); + bool implied (const vec& c); + void relocAll (ClauseAllocator& to); +}; + + +//================================================================================================= +// Implementation of inline methods: + + +inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; } +inline void SimpSolver::updateElimHeap(Var v) { + assert(use_simplification); + // if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef) + if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)) + elim_heap.update(v); } + + +inline bool SimpSolver::addClause (const vec& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); } +inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); return addClause_(add_tmp); } +inline bool SimpSolver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); } +inline bool SimpSolver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); } +inline bool SimpSolver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); } +inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } } + +inline bool SimpSolver::solve ( bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; } +inline bool SimpSolver::solve (Lit p , bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; } +inline bool SimpSolver::solve (Lit p, Lit q, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; } +inline bool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; } +inline bool SimpSolver::solve (const vec& assumps, bool do_simp, bool turn_off_simp){ + budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; } + +inline lbool SimpSolver::solveLimited (const vec& assumps, bool do_simp, bool turn_off_simp){ + assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); } + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/simp/SimpSolver.or b/lstech_maple/lstech/simp/SimpSolver.or new file mode 100755 index 0000000..6ef5d8d Binary files /dev/null and b/lstech_maple/lstech/simp/SimpSolver.or differ diff --git a/lstech_maple/lstech/simp/depend.mk b/lstech_maple/lstech/simp/depend.mk new file mode 100755 index 0000000..3bb140e --- /dev/null +++ b/lstech_maple/lstech/simp/depend.mk @@ -0,0 +1,13 @@ +/home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.o /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.or /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.od /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.op: \ + /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.cc \ + ../mtl/Sort.h ../mtl/Vec.h ../mtl/IntTypes.h ../mtl/XAlloc.h \ + ../simp/SimpSolver.h ../mtl/Queue.h ../core/Solver.h ../mtl/Heap.h \ + ../mtl/Alg.h ../utils/Options.h ../utils/ParseUtils.h \ + ../core/SolverTypes.h ../mtl/Map.h ../mtl/Alloc.h ../utils/ccnr.h \ + ../utils/System.h +/home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.o /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.or /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.od /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.op: /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.cc \ + ../utils/System.h ../mtl/IntTypes.h ../utils/ParseUtils.h \ + ../utils/Options.h ../mtl/Vec.h ../mtl/XAlloc.h ../core/Dimacs.h \ + ../core/SolverTypes.h ../mtl/Alg.h ../mtl/Map.h ../mtl/Alloc.h \ + ../simp/SimpSolver.h ../mtl/Queue.h ../core/Solver.h ../mtl/Heap.h \ + ../utils/ccnr.h diff --git a/lstech_maple/lstech/simp/glucose_static b/lstech_maple/lstech/simp/glucose_static new file mode 100755 index 0000000..884d3f3 Binary files /dev/null and b/lstech_maple/lstech/simp/glucose_static differ diff --git a/lstech_maple/lstech/utils/Makefile b/lstech_maple/lstech/utils/Makefile new file mode 100755 index 0000000..204cea5 --- /dev/null +++ b/lstech_maple/lstech/utils/Makefile @@ -0,0 +1,4 @@ +EXEC = system_test +DEPDIR = mtl + +include $(MROOT)/mtl/template.mk diff --git a/lstech_maple/lstech/utils/Options.cc b/lstech_maple/lstech/utils/Options.cc new file mode 100755 index 0000000..ec5a6e9 --- /dev/null +++ b/lstech_maple/lstech/utils/Options.cc @@ -0,0 +1,91 @@ +/**************************************************************************************[Options.cc] +Copyright (c) 2008-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include "mtl/Sort.h" +#include "utils/Options.h" +#include "utils/ParseUtils.h" + +using namespace Minisat; + +void Minisat::parseOptions(int& argc, char** argv, bool strict) +{ + int i, j; + for (i = j = 1; i < argc; i++){ + const char* str = argv[i]; + if (match(str, "--") && match(str, Option::getHelpPrefixString()) && match(str, "help")){ + if (*str == '\0') + printUsageAndExit(argc, argv); + else if (match(str, "-verb")) + printUsageAndExit(argc, argv, true); + } else { + bool parsed_ok = false; + + for (int k = 0; !parsed_ok && k < Option::getOptionList().size(); k++){ + parsed_ok = Option::getOptionList()[k]->parse(argv[i]); + + // fprintf(stderr, "checking %d: %s against flag <%s> (%s)\n", i, argv[i], Option::getOptionList()[k]->name, parsed_ok ? "ok" : "skip"); + } + + if (!parsed_ok) + if (strict && match(argv[i], "-")) + fprintf(stderr, "ERROR! Unknown flag \"%s\". Use '--%shelp' for help.\n", argv[i], Option::getHelpPrefixString()), exit(1); + else + argv[j++] = argv[i]; + } + } + + argc -= (i - j); +} + + +void Minisat::setUsageHelp (const char* str){ Option::getUsageString() = str; } +void Minisat::setHelpPrefixStr (const char* str){ Option::getHelpPrefixString() = str; } +void Minisat::printUsageAndExit (int argc, char** argv, bool verbose) +{ + const char* usage = Option::getUsageString(); + if (usage != NULL) + fprintf(stderr, usage, argv[0]); + + sort(Option::getOptionList(), Option::OptionLt()); + + const char* prev_cat = NULL; + const char* prev_type = NULL; + + for (int i = 0; i < Option::getOptionList().size(); i++){ + const char* cat = Option::getOptionList()[i]->category; + const char* type = Option::getOptionList()[i]->type_name; + + if (cat != prev_cat) + fprintf(stderr, "\n%s OPTIONS:\n\n", cat); + else if (type != prev_type) + fprintf(stderr, "\n"); + + Option::getOptionList()[i]->help(verbose); + + prev_cat = Option::getOptionList()[i]->category; + prev_type = Option::getOptionList()[i]->type_name; + } + + fprintf(stderr, "\nHELP OPTIONS:\n\n"); + fprintf(stderr, " --%shelp Print help message.\n", Option::getHelpPrefixString()); + fprintf(stderr, " --%shelp-verb Print verbose help message.\n", Option::getHelpPrefixString()); + fprintf(stderr, "\n"); + exit(0); +} + diff --git a/lstech_maple/lstech/utils/Options.h b/lstech_maple/lstech/utils/Options.h new file mode 100755 index 0000000..9c1f406 --- /dev/null +++ b/lstech_maple/lstech/utils/Options.h @@ -0,0 +1,386 @@ +/***************************************************************************************[Options.h] +Copyright (c) 2008-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_Options_h +#define Minisat_Options_h + +#include +#include +#include +#include + +#include "mtl/IntTypes.h" +#include "mtl/Vec.h" +#include "utils/ParseUtils.h" + +namespace Minisat { + +//================================================================================================== +// Top-level option parse/help functions: + + +extern void parseOptions (int& argc, char** argv, bool strict = false); +extern void printUsageAndExit(int argc, char** argv, bool verbose = false); +extern void setUsageHelp (const char* str); +extern void setHelpPrefixStr (const char* str); + + +//================================================================================================== +// Options is an abstract class that gives the interface for all types options: + + +class Option +{ + protected: + const char* name; + const char* description; + const char* category; + const char* type_name; + + static vec& getOptionList () { static vec options; return options; } + static const char*& getUsageString() { static const char* usage_str; return usage_str; } + static const char*& getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; } + + struct OptionLt { + bool operator()(const Option* x, const Option* y) { + int test1 = strcmp(x->category, y->category); + return test1 < 0 || test1 == 0 && strcmp(x->type_name, y->type_name) < 0; + } + }; + + Option(const char* name_, + const char* desc_, + const char* cate_, + const char* type_) : + name (name_) + , description(desc_) + , category (cate_) + , type_name (type_) + { + getOptionList().push(this); + } + + public: + virtual ~Option() {} + + virtual bool parse (const char* str) = 0; + virtual void help (bool verbose = false) = 0; + + friend void parseOptions (int& argc, char** argv, bool strict); + friend void printUsageAndExit (int argc, char** argv, bool verbose); + friend void setUsageHelp (const char* str); + friend void setHelpPrefixStr (const char* str); +}; + + +//================================================================================================== +// Range classes with specialization for floating types: + + +struct IntRange { + int begin; + int end; + IntRange(int b, int e) : begin(b), end(e) {} +}; + +struct Int64Range { + int64_t begin; + int64_t end; + Int64Range(int64_t b, int64_t e) : begin(b), end(e) {} +}; + +struct DoubleRange { + double begin; + double end; + bool begin_inclusive; + bool end_inclusive; + DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {} +}; + + +//================================================================================================== +// Double options: + + +class DoubleOption : public Option +{ + protected: + DoubleRange range; + double value; + + public: + DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false)) + : Option(n, d, c, ""), range(r), value(def) { + // FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly. + } + + operator double (void) const { return value; } + operator double& (void) { return value; } + DoubleOption& operator=(double x) { value = x; return *this; } + + virtual bool parse(const char* str){ + const char* span = str; + + if (!match(span, "-") || !match(span, name) || !match(span, "=")) + return false; + + char* end; + double tmp = strtod(span, &end); + + if (end == NULL) + return false; + else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){ + fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); + exit(1); + }else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){ + fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); + exit(1); } + + value = tmp; + // fprintf(stderr, "READ VALUE: %g\n", value); + + return true; + } + + virtual void help (bool verbose = false){ + fprintf(stderr, " -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n", + name, type_name, + range.begin_inclusive ? '[' : '(', + range.begin, + range.end, + range.end_inclusive ? ']' : ')', + value); + if (verbose){ + fprintf(stderr, "\n %s\n", description); + fprintf(stderr, "\n"); + } + } +}; + + +//================================================================================================== +// Int options: + + +class IntOption : public Option +{ + protected: + IntRange range; + int32_t value; + + public: + IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX)) + : Option(n, d, c, ""), range(r), value(def) {} + + operator int32_t (void) const { return value; } + operator int32_t& (void) { return value; } + IntOption& operator= (int32_t x) { value = x; return *this; } + + virtual bool parse(const char* str){ + const char* span = str; + + if (!match(span, "-") || !match(span, name) || !match(span, "=")) + return false; + + char* end; + int32_t tmp = strtol(span, &end, 10); + + if (end == NULL) + return false; + else if (tmp > range.end){ + fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); + exit(1); + }else if (tmp < range.begin){ + fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); + exit(1); } + + value = tmp; + + return true; + } + + virtual void help (bool verbose = false){ + fprintf(stderr, " -%-12s = %-8s [", name, type_name); + if (range.begin == INT32_MIN) + fprintf(stderr, "imin"); + else + fprintf(stderr, "%4d", range.begin); + + fprintf(stderr, " .. "); + if (range.end == INT32_MAX) + fprintf(stderr, "imax"); + else + fprintf(stderr, "%4d", range.end); + + fprintf(stderr, "] (default: %d)\n", value); + if (verbose){ + fprintf(stderr, "\n %s\n", description); + fprintf(stderr, "\n"); + } + } +}; + + +// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll. +#ifndef _MSC_VER + +class Int64Option : public Option +{ + protected: + Int64Range range; + int64_t value; + + public: + Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX)) + : Option(n, d, c, ""), range(r), value(def) {} + + operator int64_t (void) const { return value; } + operator int64_t& (void) { return value; } + Int64Option& operator= (int64_t x) { value = x; return *this; } + + virtual bool parse(const char* str){ + const char* span = str; + + if (!match(span, "-") || !match(span, name) || !match(span, "=")) + return false; + + char* end; + int64_t tmp = strtoll(span, &end, 10); + + if (end == NULL) + return false; + else if (tmp > range.end){ + fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name); + exit(1); + }else if (tmp < range.begin){ + fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name); + exit(1); } + + value = tmp; + + return true; + } + + virtual void help (bool verbose = false){ + fprintf(stderr, " -%-12s = %-8s [", name, type_name); + if (range.begin == INT64_MIN) + fprintf(stderr, "imin"); + else + fprintf(stderr, "%4"PRIi64, range.begin); + + fprintf(stderr, " .. "); + if (range.end == INT64_MAX) + fprintf(stderr, "imax"); + else + fprintf(stderr, "%4"PRIi64, range.end); + + fprintf(stderr, "] (default: %"PRIi64")\n", value); + if (verbose){ + fprintf(stderr, "\n %s\n", description); + fprintf(stderr, "\n"); + } + } +}; +#endif + +//================================================================================================== +// String option: + + +class StringOption : public Option +{ + const char* value; + public: + StringOption(const char* c, const char* n, const char* d, const char* def = NULL) + : Option(n, d, c, ""), value(def) {} + + operator const char* (void) const { return value; } + operator const char*& (void) { return value; } + StringOption& operator= (const char* x) { value = x; return *this; } + + virtual bool parse(const char* str){ + const char* span = str; + + if (!match(span, "-") || !match(span, name) || !match(span, "=")) + return false; + + value = span; + return true; + } + + virtual void help (bool verbose = false){ + fprintf(stderr, " -%-10s = %8s\n", name, type_name); + if (verbose){ + fprintf(stderr, "\n %s\n", description); + fprintf(stderr, "\n"); + } + } +}; + + +//================================================================================================== +// Bool option: + + +class BoolOption : public Option +{ + bool value; + + public: + BoolOption(const char* c, const char* n, const char* d, bool v) + : Option(n, d, c, ""), value(v) {} + + operator bool (void) const { return value; } + operator bool& (void) { return value; } + BoolOption& operator=(bool b) { value = b; return *this; } + + virtual bool parse(const char* str){ + const char* span = str; + + if (match(span, "-")){ + bool b = !match(span, "no-"); + + if (strcmp(span, name) == 0){ + value = b; + return true; } + } + + return false; + } + + virtual void help (bool verbose = false){ + + fprintf(stderr, " -%s, -no-%s", name, name); + + for (uint32_t i = 0; i < 32 - strlen(name)*2; i++) + fprintf(stderr, " "); + + fprintf(stderr, " "); + fprintf(stderr, "(default: %s)\n", value ? "on" : "off"); + if (verbose){ + fprintf(stderr, "\n %s\n", description); + fprintf(stderr, "\n"); + } + } +}; + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/utils/Options.or b/lstech_maple/lstech/utils/Options.or new file mode 100755 index 0000000..e18ee6e Binary files /dev/null and b/lstech_maple/lstech/utils/Options.or differ diff --git a/lstech_maple/lstech/utils/ParseUtils.h b/lstech_maple/lstech/utils/ParseUtils.h new file mode 100755 index 0000000..d307164 --- /dev/null +++ b/lstech_maple/lstech/utils/ParseUtils.h @@ -0,0 +1,122 @@ +/************************************************************************************[ParseUtils.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_ParseUtils_h +#define Minisat_ParseUtils_h + +#include +#include + +#include + +namespace Minisat { + +//------------------------------------------------------------------------------------------------- +// A simple buffered character stream class: + +static const int buffer_size = 1048576; + + +class StreamBuffer { + gzFile in; + unsigned char buf[buffer_size]; + int pos; + int size; + + void assureLookahead() { + if (pos >= size) { + pos = 0; + size = gzread(in, buf, sizeof(buf)); } } + +public: + explicit StreamBuffer(gzFile i) : in(i), pos(0), size(0) { assureLookahead(); } + + int operator * () const { return (pos >= size) ? EOF : buf[pos]; } + void operator ++ () { pos++; assureLookahead(); } + int position () const { return pos; } +}; + + +//------------------------------------------------------------------------------------------------- +// End-of-file detection functions for StreamBuffer and char*: + + +static inline bool isEof(StreamBuffer& in) { return *in == EOF; } +static inline bool isEof(const char* in) { return *in == '\0'; } + +//------------------------------------------------------------------------------------------------- +// Generic parse functions parametrized over the input-stream type. + + +template +static void skipWhitespace(B& in) { + while ((*in >= 9 && *in <= 13) || *in == 32) + ++in; } + + +template +static void skipLine(B& in) { + for (;;){ + if (isEof(in)) return; + if (*in == '\n') { ++in; return; } + ++in; } } + + +template +static int parseInt(B& in) { + int val = 0; + bool neg = false; + skipWhitespace(in); + if (*in == '-') neg = true, ++in; + else if (*in == '+') ++in; + if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3); + while (*in >= '0' && *in <= '9') + val = val*10 + (*in - '0'), + ++in; + return neg ? -val : val; } + + +// String matching: in case of a match the input iterator will be advanced the corresponding +// number of characters. +template +static bool match(B& in, const char* str) { + int i; + for (i = 0; str[i] != '\0'; i++) + if (in[i] != str[i]) + return false; + + in += i; + + return true; +} + +// String matching: consumes characters eagerly, but does not require random access iterator. +template +static bool eagerMatch(B& in, const char* str) { + for (; *str != '\0'; ++str, ++in) + if (*str != *in) + return false; + return true; } + + +//================================================================================================= +} + +#endif diff --git a/lstech_maple/lstech/utils/System.cc b/lstech_maple/lstech/utils/System.cc new file mode 100755 index 0000000..4662f1b --- /dev/null +++ b/lstech_maple/lstech/utils/System.cc @@ -0,0 +1,95 @@ +/***************************************************************************************[System.cc] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#include "utils/System.h" + +#if defined(__linux__) + +#include +#include + +using namespace Minisat; + +// TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and +// one for reading the current virtual memory size. + +static inline int memReadStat(int field) +{ + char name[256]; + pid_t pid = getpid(); + int value; + + sprintf(name, "/proc/%d/statm", pid); + FILE* in = fopen(name, "rb"); + if (in == NULL) return 0; + + for (; field >= 0; field--) + if (fscanf(in, "%d", &value) != 1) + printf("ERROR! Failed to parse memory statistics from \"/proc\".\n"), exit(1); + fclose(in); + return value; +} + + +static inline int memReadPeak(void) +{ + char name[256]; + pid_t pid = getpid(); + + sprintf(name, "/proc/%d/status", pid); + FILE* in = fopen(name, "rb"); + if (in == NULL) return 0; + + // Find the correct line, beginning with "VmPeak:": + int peak_kb = 0; + while (!feof(in) && fscanf(in, "VmPeak: %d kB", &peak_kb) != 1) + while (!feof(in) && fgetc(in) != '\n') + ; + fclose(in); + + return peak_kb; +} + +double Minisat::memUsed() { return (double)memReadStat(0) * (double)getpagesize() / (1024*1024); } +double Minisat::memUsedPeak() { + double peak = memReadPeak() / 1024; + return peak == 0 ? memUsed() : peak; } + +#elif defined(__FreeBSD__) + +double Minisat::memUsed(void) { + struct rusage ru; + getrusage(RUSAGE_SELF, &ru); + return (double)ru.ru_maxrss / 1024; } +double MiniSat::memUsedPeak(void) { return memUsed(); } + + +#elif defined(__APPLE__) +#include + +double Minisat::memUsed(void) { + malloc_statistics_t t; + malloc_zone_statistics(NULL, &t); + return (double)t.max_size_in_use / (1024*1024); } +double Minisat::memUsedPeak(void) {return memUsed(); } +#else +double Minisat::memUsed() { + return 0; } +#endif diff --git a/lstech_maple/lstech/utils/System.h b/lstech_maple/lstech/utils/System.h new file mode 100755 index 0000000..1758192 --- /dev/null +++ b/lstech_maple/lstech/utils/System.h @@ -0,0 +1,60 @@ +/****************************************************************************************[System.h] +Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson +Copyright (c) 2007-2010, Niklas Sorensson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, +sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT +NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +**************************************************************************************************/ + +#ifndef Minisat_System_h +#define Minisat_System_h + +#if defined(__linux__) +#include +#endif + +#include "mtl/IntTypes.h" + +//------------------------------------------------------------------------------------------------- + +namespace Minisat { + +static inline double cpuTime(void); // CPU-time in seconds. +extern double memUsed(); // Memory in mega bytes (returns 0 for unsupported architectures). +extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures). + +} + +//------------------------------------------------------------------------------------------------- +// Implementation of inline functions: + +#if defined(_MSC_VER) || defined(__MINGW32__) +#include + +static inline double Minisat::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; } + +#else +#include +#include +#include + +static inline double Minisat::cpuTime(void) { + struct rusage ru; + getrusage(RUSAGE_SELF, &ru); + return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; } + +#endif + +#endif diff --git a/lstech_maple/lstech/utils/System.or b/lstech_maple/lstech/utils/System.or new file mode 100755 index 0000000..649dc6e Binary files /dev/null and b/lstech_maple/lstech/utils/System.or differ diff --git a/lstech_maple/lstech/utils/ccnr.cc b/lstech_maple/lstech/utils/ccnr.cc new file mode 100755 index 0000000..55c1274 --- /dev/null +++ b/lstech_maple/lstech/utils/ccnr.cc @@ -0,0 +1,822 @@ +#include "ccnr.h" +#include +using std::ofstream; +#define pop(stack) stack[--stack ## _fill_pointer] +#define push(item, stack) stack[stack ## _fill_pointer++] = item +#define ccanr_Mersenne_N 624 +#define ccanr_Mersenne_M 397 +#define ccanr_Mersenne_MATRIX_A 0x9908b0dfUL +#define ccanr_Mersenne_UPPER_MASK 0x80000000UL +#define ccanr_Mersenne_LOWER_MASK 0x7fffffffUL +void ccanr_Mersenne_init_with_seed(ccanr_randgen* randgen, int seed); +int ccanr_Mersenne_next(ccanr_randgen* randgen, int bound); +int ccanr_rand(CCAnr*, int); + + +int pick_var(CCAnr*); +void init(CCAnr*,char*); +void unit_propagation(CCAnr*); +void preprocess(CCAnr*); +void flip(CCAnr*,int); +void smooth_clause_weights(CCAnr*); +void update_clause_weights(CCAnr*); +void set_clause_weighting(CCAnr*); + +void default_initialize(CCAnr* lssolver){ + lssolver->formula_len=0; + lssolver->unitclause_queue_beg_pointer=0; + lssolver->unitclause_queue_end_pointer=0; + lssolver->max_tries = 10000; + lssolver->max_flips = 200000000; + lssolver->ave_weight=1; + lssolver->delta_total_weight=0; + lssolver->q_scale=0; + lssolver->q_init=0; + lssolver->mems_left=50000000; +} + +void alloc_memory(CCAnr *lssolver){ + int var_mem = lssolver->num_vars+2; + int cls_mem = lssolver->num_clauses+2; + lssolver->score_inc_vars = (int*)malloc(sizeof(int)*var_mem); + lssolver->score_inc_flag = (int*)malloc(sizeof(int)*var_mem); + lssolver->var_lit = (lit**)malloc(sizeof(lit*)*var_mem); + lssolver->var_lit_count = (int*)malloc(sizeof(int)*var_mem); + lssolver->clause_lit = (lit**)malloc(sizeof(lit*)*cls_mem); + lssolver->clause_lit_count = (int*)malloc(sizeof(int)*cls_mem); + lssolver->score = (int*)malloc(sizeof(int)*var_mem); + lssolver->time_stamp = (int*)malloc(sizeof(int)*var_mem); + lssolver->fix = (int*)malloc(sizeof(int)*var_mem); + lssolver->cscc = (int*)malloc(sizeof(int)*var_mem); + lssolver->clause_weight = (int*)malloc(sizeof(int)*cls_mem); + lssolver->sat_count = (int*)malloc(sizeof(int)*cls_mem); + lssolver->sat_var = (int*)malloc(sizeof(int)*cls_mem); + lssolver->unsat_stack = (int*)malloc(sizeof(int)*cls_mem); + lssolver->index_in_unsat_stack=(int*)malloc(sizeof(int)*cls_mem); + lssolver->unsatvar_stack = (int*)malloc(sizeof(int)*var_mem); + lssolver->index_in_unsatvar_stack = (int*)malloc(sizeof(int)*var_mem); + lssolver->unsat_app_count = (int*)malloc(sizeof(int)*var_mem); + lssolver->goodvar_stack = (int*)malloc(sizeof(int)*var_mem); + lssolver->already_in_goodvar_stack = (int*)malloc(sizeof(int)*var_mem); + lssolver->unitclause_queue = (lit*)malloc(sizeof(lit)*var_mem); + lssolver->clause_delete = (int*)malloc(sizeof(int)*cls_mem); + lssolver->cur_soln = (char*)malloc(sizeof(int)*var_mem); + lssolver->best_soln = (char*)malloc(sizeof(int)*var_mem); + lssolver->conflict_ct = (int*)malloc(sizeof(int)*var_mem); + lssolver->in_conflict = (int*)malloc(sizeof(int)*var_mem); + for(int i=1;i<=lssolver->num_vars;++i) lssolver->conflict_ct[i]=0; +} + +void free_memory(CCAnr *lssolver) +{ + int i; + for (i = 0; i < lssolver->num_clauses; i++) + { + free(lssolver->clause_lit[i]); + } + + for(i=1; i<=lssolver->num_vars; ++i) + { + free(lssolver->var_lit[i]); + } + + free(lssolver->score_inc_vars); + free(lssolver->score_inc_flag); + free(lssolver->var_lit); + free(lssolver->var_lit_count); + free(lssolver->clause_lit); + free(lssolver->clause_lit_count); + free(lssolver->score); + free(lssolver->time_stamp); + free(lssolver->fix); + free(lssolver->cscc); + free(lssolver->clause_weight); + free(lssolver->sat_count); + free(lssolver->sat_var); + free(lssolver->unsat_stack); + free(lssolver->index_in_unsat_stack); + free(lssolver->unsatvar_stack); + free(lssolver->index_in_unsatvar_stack); + free(lssolver->unsat_app_count); + free(lssolver->goodvar_stack); + free(lssolver->already_in_goodvar_stack); + free(lssolver->unitclause_queue); + free(lssolver->clause_delete); + free(lssolver->cur_soln); + free(lssolver->best_soln); + free(lssolver->conflict_ct); + free(lssolver->in_conflict); +} + + +//pick a var to be flip +int pick_var(CCAnr *lssolver) +{ + int i,k,c,v; + int best_var; + lit* clause_c; + + /**Greedy Mode**/ + /*CCD (configuration changed decreasing) mode, the level with configuation chekcing*/ + if(lssolver->goodvar_stack_fill_pointer>0) + { + lssolver->mems_left -= lssolver->goodvar_stack_fill_pointer; + best_var = lssolver->goodvar_stack[0]; + + for(i=1; igoodvar_stack_fill_pointer; ++i) + { + v=lssolver->goodvar_stack[i]; + if(lssolver->score[v]>lssolver->score[best_var]) best_var = v; + else if(lssolver->score[v]==lssolver->score[best_var] && lssolver->time_stamp[v]time_stamp[best_var]) best_var = v; + } + + return best_var; + } + + /*SD (significant decreasing) mode, the level with aspiration*/ + best_var = 0; + for(i=0; iunsatvar_stack_fill_pointer; ++i) + { + if(lssolver->score[lssolver->unsatvar_stack[i]]>lssolver->ave_weight) + { + best_var = lssolver->unsatvar_stack[i]; + break; + } + } + + for(++i; iunsatvar_stack_fill_pointer; ++i) + { + v=lssolver->unsatvar_stack[i]; + if(lssolver->score[v]>lssolver->score[best_var]) best_var = v; + else if(lssolver->score[v]==lssolver->score[best_var] && lssolver->time_stamp[v]time_stamp[best_var]) best_var = v; + } + + if(best_var!=0) return best_var; + + /**Diversification Mode**/ + update_clause_weights(lssolver); + + /*focused random walk*/ + c = lssolver->unsat_stack[ccanr_rand(lssolver,lssolver->unsat_stack_fill_pointer)]; + clause_c = lssolver->clause_lit[c]; + best_var = clause_c[0].var_num; + for(k=1; kclause_lit_count[c]; ++k) + { + v=clause_c[k].var_num; + //if(time_stamp[v]score[v]>lssolver->score[best_var]) best_var = v; + else if(lssolver->score[v]==lssolver->score[best_var]&&lssolver->time_stamp[v]time_stamp[best_var]) best_var = v; + } + + return best_var; +} + +//set functions in the algorithm +void settings(CCAnr *lssolver,char *soln) +{ + set_clause_weighting(lssolver); + init(lssolver,soln); +} + +bool local_search(CCAnr *lssolver) +{ + int flipvar; + lssolver->best_cost = lssolver->num_clauses; + for (lssolver->step = 0; lssolver->stepmax_flips; lssolver->step++) + { + //find a solution + if(lssolver->unsat_stack_fill_pointer < lssolver->best_cost){ + lssolver->best_cost = lssolver->unsat_stack_fill_pointer; + for(int i=1;i<=lssolver->num_vars;++i) lssolver->best_soln[i]=lssolver->cur_soln[i]; + } + if(lssolver->unsat_stack_fill_pointer==0) return true; + if(lssolver->mems_left<0 && lssolver->step>1000) return false; + flipvar = pick_var(lssolver); + flip(lssolver,flipvar); + lssolver->time_stamp[flipvar] = lssolver->step; + + //update conflicts information + for(int i=0;iunsatvar_stack_fill_pointer;++i) + ++lssolver->conflict_ct[lssolver->unsatvar_stack[i]]; + + } + return false; +} + +inline void unsat(CCAnr *lssolver, int clause) +{ + lssolver->index_in_unsat_stack[clause] = lssolver->unsat_stack_fill_pointer; + push(clause,lssolver->unsat_stack); + + //update appreance count of each var in unsat clause and update stack of vars in unsat clauses + int v; + for(lit* p=lssolver->clause_lit[clause]; (v=p->var_num)!=0; p++) + { + lssolver->unsat_app_count[v]++; + if(lssolver->unsat_app_count[v]==1) + { + lssolver->index_in_unsatvar_stack[v] = lssolver->unsatvar_stack_fill_pointer; + push(v,lssolver->unsatvar_stack); + } + } +} + +inline void sat(CCAnr *lssolver, int clause) +{ + int index,last_unsat_clause; + + //since the clause is satisfied, its position can be reused to store the last_unsat_clause + last_unsat_clause = pop(lssolver->unsat_stack); + index = lssolver->index_in_unsat_stack[clause]; + lssolver->unsat_stack[index] = last_unsat_clause; + lssolver->index_in_unsat_stack[last_unsat_clause] = index; + + //update appreance count of each var in unsat clause and update stack of vars in unsat clauses + int v,last_unsat_var; + for(lit* p=lssolver->clause_lit[clause]; (v=p->var_num)!=0; p++) + { + lssolver->unsat_app_count[v]--; + if(lssolver->unsat_app_count[v]==0) + { + last_unsat_var = pop(lssolver->unsatvar_stack); + index = lssolver->index_in_unsatvar_stack[v]; + lssolver->unsatvar_stack[index] = last_unsat_var; + lssolver->index_in_unsatvar_stack[last_unsat_var] = index; + } + } +} + +//initiation of the algorithm +void init(CCAnr *lssolver,char *soln) +{ + int v,c; + int i,j; + + //Initialize edge weights + for (c = 0; cnum_clauses; c++) + lssolver->clause_weight[c] = 1; + + //init unsat_stack + lssolver->unsat_stack_fill_pointer = 0; + lssolver->unsatvar_stack_fill_pointer = 0; + + //init solution + for (v = 1; v <= lssolver->num_vars; v++) { + + if(lssolver->fix[v]==0){ + if(soln==NULL){ + if(ccanr_rand(lssolver,2)==1) lssolver->cur_soln[v] = 1; + else lssolver->cur_soln[v] = 0; + }else{ + lssolver->cur_soln[v] = soln[v-1]; + } + + lssolver->time_stamp[v] = 0; + lssolver->unsat_app_count[v] = 0; + lssolver->cscc[v] = 1; + lssolver->score_inc_flag[v]=0; + } + + + } + + /* figure out sat_count, and init unsat_stack */ + for (c=0; cnum_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) continue; + + lssolver->sat_count[c] = 0; + + for(j=0; jclause_lit_count[c]; ++j) + { + if (lssolver->cur_soln[lssolver->clause_lit[c][j].var_num] == lssolver->clause_lit[c][j].sense) + { + lssolver->sat_count[c]++; + lssolver->sat_var[c] = lssolver->clause_lit[c][j].var_num; + } + } + + if (lssolver->sat_count[c] == 0) + unsat(lssolver,c); + } + + /*figure out var score*/ + int lit_count; + for (v=1; v<=lssolver->num_vars; v++) + { + if(lssolver->fix[v]==1) + { + lssolver->score[v] = -10000000; + continue; + } + + lssolver->score[v] = 0; + + lit_count = lssolver->var_lit_count[v]; + + for(i=0; ivar_lit[v][i].clause_num; + if (lssolver->sat_count[c]==0) lssolver->score[v]++; + else if (lssolver->sat_count[c]==1 && lssolver->var_lit[v][i].sense==lssolver->cur_soln[v]) lssolver->score[v]--; + } + } + + + //init goodvars stack + lssolver->goodvar_stack_fill_pointer = 0; + for (v=1; v<=lssolver->num_vars; v++) + { + if(lssolver->fix[v]==1) continue; + if(lssolver->score[v]>0)// && conf_change[v]==1) + { + lssolver->already_in_goodvar_stack[v] = 1; + push(v,lssolver->goodvar_stack); + + } + else lssolver->already_in_goodvar_stack[v] = 0; + } + + //setting for the virtual var 0 + lssolver->time_stamp[0]=0; + //pscore[0]=0; +} + +void flip(CCAnr *lssolver, int flipvar) +{ + lssolver->cur_soln[flipvar] = 1 - lssolver->cur_soln[flipvar]; + + lssolver->score_inc_count=0; + + int i; + int v,c; + + lit* clause_c; + + int org_flipvar_score = lssolver->score[flipvar]; + + //update related clauses and neighbor vars + lssolver->mems_left-=lssolver->var_lit_count[flipvar]; + for(lit *q = lssolver->var_lit[flipvar]; (c=q->clause_num)>=0; q++) + { + clause_c = lssolver->clause_lit[c]; + if(lssolver->cur_soln[flipvar] == q->sense) + { + ++lssolver->sat_count[c]; + + if (lssolver->sat_count[c] == 2) //sat_count from 1 to 2 + { + lssolver->score[lssolver->sat_var[c]] += lssolver->clause_weight[c]; + + if(lssolver->score_inc_flag[lssolver->sat_var[c]]!=1) + { + lssolver->score_inc_vars[lssolver->score_inc_count++]=lssolver->sat_var[c]; + lssolver->score_inc_flag[lssolver->sat_var[c]]=1; + } + } + else if (lssolver->sat_count[c] == 1) // sat_count from 0 to 1 + { + lssolver->sat_var[c] = flipvar;//record the only true lit's var + for(lit* p=clause_c; (v=p->var_num)!=0; p++) + { + lssolver->score[v] -= lssolver->clause_weight[c]; + lssolver->cscc[v] = 1; + } + + sat(lssolver,c); + } + } + else // cur_soln[flipvar] != cur_lit.sense + { + --lssolver->sat_count[c]; + if (lssolver->sat_count[c] == 1) //sat_count from 2 to 1 + { + for(lit* p=clause_c; (v=p->var_num)!=0; p++) + { + if(p->sense == lssolver->cur_soln[v] ) + { + lssolver->score[v] -= lssolver->clause_weight[c]; + lssolver->sat_var[c] = v; + break; + } + } + } + else if (lssolver->sat_count[c] == 0) //sat_count from 1 to 0 + { + for(lit* p=clause_c; (v=p->var_num)!=0; p++) + { + lssolver->score[v] += lssolver->clause_weight[c]; + lssolver->cscc[v] = 1; + + if(lssolver->score_inc_flag[v]!=1) + { + lssolver->score_inc_vars[lssolver->score_inc_count++]=v; + lssolver->score_inc_flag[v]=1; + } + } + unsat(lssolver,c); + }//end else if + + }//end else + } + + lssolver->score[flipvar] = -org_flipvar_score; + + lssolver->cscc[flipvar] = 0; + + /*update CCD */ + int index; + + for(index=lssolver->goodvar_stack_fill_pointer-1; index>=0; index--) + { + v = lssolver->goodvar_stack[index]; + if(lssolver->score[v]<=0) + { + lssolver->goodvar_stack[index] = pop(lssolver->goodvar_stack); + lssolver->already_in_goodvar_stack[v] = 0; + } + } + + + for (i=0; iscore_inc_count; ++i) + { + v = lssolver->score_inc_vars[i]; + if(lssolver->score[v]>0 && lssolver->cscc[v]==1 && lssolver->already_in_goodvar_stack[v] ==0) + { + push(v,lssolver->goodvar_stack); + lssolver->already_in_goodvar_stack[v] = 1; + } + lssolver->score_inc_flag[v]=0; + } +} + +void update_after_build(CCAnr *lssolver){ + int i,c,v; + lssolver->avg_clause_len = (double)(lssolver->formula_len+0.0)/lssolver->num_clauses; + + //creat var literal arrays + for (v=1; v<=lssolver->num_vars; ++v) + { + lssolver->var_lit[v] = (lit*)malloc(sizeof(lit)*(lssolver->var_lit_count[v]+1)); + lssolver->var_lit_count[v] = 0; //reset to 0, for build up the array + } + //scan all clauses to build up var literal arrays + for (c = 0; c < lssolver->num_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) + continue; + for(i=0; iclause_lit_count[c]; ++i) + { + v = lssolver->clause_lit[c][i].var_num; + lssolver->var_lit[v][lssolver->var_lit_count[v]] = lssolver->clause_lit[c][i]; + ++lssolver->var_lit_count[v]; + } + } + for (v=1; v<=lssolver->num_vars; ++v) //set boundary + lssolver->var_lit[v][lssolver->var_lit_count[v]].clause_num=-1; + + for (int c = 0; c < lssolver->num_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) { + continue; + } + + for(int i=0; iclause_lit_count[c]; ++i) + { + int v = lssolver->clause_lit[c][i].var_num; + + if (v > 0 && v <= lssolver->num_vars); + else { + printf("\n222wrong v %d clause id: %d\n", v, c); + for(int ii=0; iiclause_lit_count[c]; ++ii) + printf("%d ", lssolver->clause_lit[c][ii].var_num); + puts(""); + } + if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses); + else printf("222wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]); + + } + } + // printf("finish check 2\n"); + if(lssolver->unitclause_queue_end_pointer>0) preprocess(lssolver); + +} + + + +void smooth_clause_weights(CCAnr *lssolver) +{ + int j,c,v; + int new_total_weight=0; + + for (v=1; v<=lssolver->num_vars; ++v) + lssolver->score[v] = 0; + + //smooth clause score and update score of variables + for (c = 0; cnum_clauses; ++c) + { + if (lssolver->clause_delete[c]==1) continue; + + lssolver->clause_weight[c] = lssolver->clause_weight[c]*lssolver->p_scale+lssolver->scale_ave; + if(lssolver->clause_weight[c]<1) lssolver->clause_weight[c] = 1; + + new_total_weight+=lssolver->clause_weight[c]; + + //update score of variables in this clause + if (lssolver->sat_count[c]==0) + { + for(j=0; jclause_lit_count[c]; ++j) + { + lssolver->score[lssolver->clause_lit[c][j].var_num] += lssolver->clause_weight[c]; + } + } + else if(lssolver->sat_count[c]==1) + lssolver->score[lssolver->sat_var[c]]-=lssolver->clause_weight[c]; + } + + lssolver->ave_weight=new_total_weight/lssolver->num_clauses; +} + +void update_clause_weights(CCAnr *lssolver) +{ + int i,v; + lssolver->mems_left -= lssolver->unsat_stack_fill_pointer; + for(i=0; i < lssolver->unsat_stack_fill_pointer; ++i) + lssolver->clause_weight[lssolver->unsat_stack[i]]++; + + for(i=0; iunsatvar_stack_fill_pointer; ++i) + { + v = lssolver->unsatvar_stack[i]; + lssolver->score[v] += lssolver->unsat_app_count[v]; + if(lssolver->score[v]>0 && lssolver->cscc[v]==1 && lssolver->already_in_goodvar_stack[v] ==0) + { + push(v,lssolver->goodvar_stack); + lssolver->already_in_goodvar_stack[v] =1; + } + } + + lssolver->delta_total_weight+=lssolver->unsat_stack_fill_pointer; + if(lssolver->delta_total_weight>=lssolver->num_clauses) + { + lssolver->ave_weight+=1; + lssolver->delta_total_weight -= lssolver->num_clauses; + + //smooth weights + if(lssolver->ave_weight>lssolver->threshold) + smooth_clause_weights(lssolver); + } +} + +void set_clause_weighting(CCAnr *lssolver) +{ + lssolver->threshold=300; + lssolver->p_scale=0.3; + if(lssolver->q_init==0) + { + if(lssolver->ratio<=15) lssolver->q_scale=0; + else lssolver->q_scale=0.7; + } + else + { + if(lssolver->q_scale<0.5) //0 + lssolver->q_scale = 0.7; + else + lssolver->q_scale = 0; + } + + lssolver->scale_ave=(lssolver->threshold+1)*lssolver->q_scale; + lssolver->q_init = 1; +} + +//preprocess +void unit_propagation(CCAnr *lssolver) +{ + lit uc_lit; + int uc_clause; + int uc_var; + bool uc_sense; + + int c; + int i,j; + lit cur; + + + for(lssolver->unitclause_queue_beg_pointer=0; lssolver->unitclause_queue_beg_pointer < lssolver->unitclause_queue_end_pointer; lssolver->unitclause_queue_beg_pointer++) + { + uc_lit = lssolver->unitclause_queue[lssolver->unitclause_queue_beg_pointer]; + + uc_var = uc_lit.var_num; + uc_sense = uc_lit.sense; + + if(lssolver->fix[uc_var]==1) {if(uc_sense!=lssolver->cur_soln[uc_var])printf("c wants to fix a variable twice, forbid\n");continue;} + + lssolver->cur_soln[uc_var] = uc_sense;//fix the variable in unit clause + lssolver->fix[uc_var] = 1; + + for(i = 0; ivar_lit_count[uc_var]; ++i) + { + cur = lssolver->var_lit[uc_var][i]; + c = cur.clause_num; + + if(lssolver->clause_delete[c]==1) continue; + + if(cur.sense == uc_sense)//then remove the clause from var's var_lit[] array + { + lssolver->clause_delete[c]=1; + lssolver->clause_lit_count[c]=0; + } + else + { + if(lssolver->clause_lit_count[c]==2) + { + if(lssolver->clause_lit[c][0].var_num == uc_var) + { + lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[c][1]; + } + else + { + lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[c][0]; + } + + lssolver->clause_delete[c]=1; + lssolver->clause_lit_count[c]=0; + } + else + { + for(j=0; jclause_lit_count[c]; ++j) + { + if(lssolver->clause_lit[c][j].var_num == uc_var) + { + lssolver->clause_lit[c][j]=lssolver->clause_lit[c][lssolver->clause_lit_count[c]-1]; + + lssolver->clause_lit_count[c]--; + + break; + } + } + } + } + } + } + +} + +void preprocess(CCAnr *lssolver) +{ + int c,v,i; + int delete_clause_count=0; + int fix_var_count=0; + // ofstream fout("test2.txt"); + + // for (int c = 0; c < lssolver->num_clauses; ++c) + // { + // if(lssolver->clause_delete[c]==1) { + // continue; + // } + // fout << c << ": "; + // for(int i=0; iclause_lit_count[c]; ++i) + // { + // int v = lssolver->clause_lit[c][i].var_num; + // int p = lssolver->clause_lit[c][i].sense; + // fout << (p==1 ? v:-v) << " "; + // } + // fout << std::endl; + // } + // fout.close(); + unit_propagation(lssolver); + + //rescan all clauses to build up var literal arrays + for (v=1; v<=lssolver->num_vars; ++v) + lssolver->var_lit_count[v] = 0; + + lssolver->max_clause_len = 0; + lssolver->min_clause_len = lssolver->num_vars; + int formula_len=0; + + for (c = 0; c < lssolver->num_clauses; ++c) + { + if(lssolver->clause_delete[c]==1) { + delete_clause_count++; + continue; + } + + for(i=0; iclause_lit_count[c]; ++i) + { + v = lssolver->clause_lit[c][i].var_num; + + if (v > 0 && v <= lssolver->num_vars); + else { + printf("\n444wrong v %d clause id: %d\n", v, c); + for(int ii=0; iiclause_lit_count[c]; ++ii) + printf("%d ", lssolver->clause_lit[c][ii].var_num); + puts(""); + } + if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses); + else printf("444wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]); + + lssolver->var_lit[v][lssolver->var_lit_count[v]] = lssolver->clause_lit[c][i]; + ++lssolver->var_lit_count[v]; + } + lssolver->clause_lit[c][i].var_num=0; //new clause boundary + lssolver->clause_lit[c][i].clause_num = -1; + + //about clause length + formula_len += lssolver->clause_lit_count[c]; + + if(lssolver->clause_lit_count[c] > lssolver->max_clause_len) + lssolver->max_clause_len = lssolver->clause_lit_count[c]; + else if(lssolver->clause_lit_count[c] < lssolver->min_clause_len) + lssolver->min_clause_len = lssolver->clause_lit_count[c]; + } + + lssolver->avg_clause_len = (double)(formula_len+0.0)/lssolver->num_clauses; + + for (v=1; v<=lssolver->num_vars; ++v) + { + if(lssolver->fix[v]==1) + { + fix_var_count++; + } + lssolver->var_lit[v][lssolver->var_lit_count[v]].clause_num=-1;//new var_lit boundary + } + lssolver->fix_var_ct = fix_var_count; + lssolver->del_cls_ct = delete_clause_count; + // printf("c unit propagation fixes %d variables, and deletes %d clauses\n",fix_var_count,delete_clause_count); + +} + + + +void ccanr_merseene_init(CCAnr* lssolver, int seed){ + ccanr_Mersenne_init_with_seed(&(lssolver->randgen),seed); +} + +int ccanr_rand(CCAnr* lssolver,int bound){ + return ccanr_Mersenne_next(&(lssolver->randgen),bound); +} + + +void ccanr_Mersenne_init_with_seed(ccanr_randgen* randgen, int seed){ + unsigned int s = ((unsigned int) (seed << 1)) + 1; + randgen->mt[0] = s & 0xffffffffUL; + for(randgen->mti = 1; randgen->mti < ccanr_Mersenne_N; randgen->mti++) { + randgen->mt[randgen->mti] = (1812433253UL * (randgen->mt[randgen->mti - 1] ^ (randgen->mt[randgen->mti - 1] >> 30)) + randgen->mti); + randgen->mt[randgen->mti] &= 0xffffffffUL; + } +} + +int ccanr_Mersenne_next31(ccanr_randgen* randgen){ + unsigned int y; + static unsigned int mag01[2] = {0x0UL, ccanr_Mersenne_MATRIX_A}; + if(randgen->mti >= ccanr_Mersenne_N) { + int kk; + for(kk = 0; kk < ccanr_Mersenne_N - ccanr_Mersenne_M; kk++) { + y = (randgen->mt[kk] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[kk + 1] & ccanr_Mersenne_LOWER_MASK); + randgen->mt[kk] = randgen->mt[kk + ccanr_Mersenne_M] ^ (y >> 1) ^ mag01[y & 0x1UL]; + } + for(; kk < ccanr_Mersenne_N - 1; kk++) { + y = (randgen->mt[kk] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[kk + 1] & ccanr_Mersenne_LOWER_MASK); + randgen->mt[kk] = randgen->mt[kk + (ccanr_Mersenne_M - ccanr_Mersenne_N)] ^ (y >> 1) ^ mag01[y & 0x1UL]; + } + y = (randgen->mt[ccanr_Mersenne_N - 1] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[0] & ccanr_Mersenne_LOWER_MASK); + randgen->mt[ccanr_Mersenne_N - 1] = randgen->mt[ccanr_Mersenne_M - 1] ^ (y >> 1) ^ mag01[y & 0x1UL]; + randgen->mti = 0; + } + y = randgen->mt[randgen->mti++]; + y ^= (y >> 11); + y ^= (y << 7) & 0x9d2c5680UL; + y ^= (y << 15) & 0xefc60000UL; + y ^= (y >> 18); + return (int) (y>>1); +} + +int ccanr_Mersenne_next(ccanr_randgen* randgen, int bound){ + unsigned int value; + do { + value = ccanr_Mersenne_next31(randgen); + } while(value + (unsigned int) bound >= 0x80000000UL); + return (int) (value % bound); +} + + +void init_CCAnr(CCAnr* lssolver){ + int seed = 1; + ccanr_merseene_init(lssolver,seed); + default_initialize(lssolver); +} + +void reinit_CCAnr(CCAnr *lssolver){ + if (lssolver) free_memory(lssolver); + init_CCAnr(lssolver); +} + +void confl_trans(CCAnr* lssolver){ + lssolver->in_conflict_sz = 0; + if(lssolver->step==0) return; + for(int i=1;i<=lssolver->num_vars;++i){ + lssolver->conflict_ct[i] = lssolver->conflict_ct[i]*100/lssolver->step; + if(lssolver->conflict_ct[i]>0){ + lssolver->in_conflict[lssolver->in_conflict_sz++] = i; + } + } +} \ No newline at end of file diff --git a/lstech_maple/lstech/utils/ccnr.h b/lstech_maple/lstech/utils/ccnr.h new file mode 100755 index 0000000..af39a70 --- /dev/null +++ b/lstech_maple/lstech/utils/ccnr.h @@ -0,0 +1,129 @@ +#ifndef _CCA_H_ +#define _CCA_H_ + +#include +#include +#include +#include +#include //these two h files are for linux +#include + +// mersenne twist +typedef struct ccanr_randgen ccanr_randgen; +struct ccanr_randgen +{ + unsigned mt[624]; + int mti; +}; + + +// Define a data structure for a literal in the SAT problem. +typedef struct lit lit; + +struct lit { + int clause_num; //clause num, begin with 0 + int var_num; //variable num, begin with 1 + int sense; //is 1 for true literals, 0 for false literals. +}; + +typedef struct CCAnr CCAnr; + +struct CCAnr{ + /*parameters of the instance*/ + int num_vars; //var index from 1 to num_vars + int num_clauses; //clause index from 0 to num_clauses-1 + int max_clause_len; + int min_clause_len; + int formula_len; + double avg_clause_len; + double ratio; + int ave_weight; //significant score(sigscore) needed for aspiration + int delta_total_weight; + int threshold; + float p_scale;//w=w*p+ave_w*q + float q_scale; + int scale_ave;//scale_ave==ave_weight*q_scale + int q_init; + long long mems_left; + //cutoff + int max_tries; + int tries; + int max_flips; + int step; + int* score_inc_vars; + int* score_inc_flag; + int score_inc_count; + /* literal arrays */ + lit** var_lit; //var_lit[i][j] means the j'th literal of var i. + int* var_lit_count; //amount of literals of each var + lit** clause_lit; //clause_lit[i][j] means the j'th literal of clause i. + int* clause_lit_count; // amount of literals in each clause + + + /* Information about the variables. */ + int* score; + int* time_stamp; + int* fix; + int* cscc; + + /* Information about the clauses */ + int* clause_weight; + int* sat_count; + int* sat_var; + + //unsat clauses stack + int* unsat_stack; //store the unsat clause number + int unsat_stack_fill_pointer; + int* index_in_unsat_stack;//which position is a clause in the unsat_stack + + //variables in unsat clauses + int* unsatvar_stack; + int unsatvar_stack_fill_pointer; + int* index_in_unsatvar_stack; + int* unsat_app_count; //a varible appears in how many unsat clauses + + //configuration changed decreasing variables (score>0 and confchange=1) + int* goodvar_stack; + int goodvar_stack_fill_pointer; + int* already_in_goodvar_stack; + + //unit clauses preprocess + lit* unitclause_queue; + int unitclause_queue_beg_pointer; + int unitclause_queue_end_pointer; + int* clause_delete; + + /* Information about solution */ + char* cur_soln; //the current solution, with 1's for True variables, and 0's for False variables + ccanr_randgen randgen; + char* best_soln; + int best_cost; + // confl_trans + int* conflict_ct; + int in_conflict_sz; + int* in_conflict; + + // preprocess + int fix_var_ct; + int del_cls_ct; +}; + + +void init_CCAnr(CCAnr*); +void reinit_CCAnr(CCAnr*); +void confl_trans(CCAnr*); + + +bool local_search(CCAnr*); +int build_instance(CCAnr*,char *filename); +void print_solution(CCAnr*); +int verify_sol(CCAnr*); +void alloc_memory(CCAnr*); +void free_memory(CCAnr*); +void settings(CCAnr*, char*); +void ccanr_merseene_init(CCAnr*, int); +void update_after_build(CCAnr*); + + +#endif + diff --git a/lstech_maple/lstech/utils/ccnr.or b/lstech_maple/lstech/utils/ccnr.or new file mode 100755 index 0000000..36da6ae Binary files /dev/null and b/lstech_maple/lstech/utils/ccnr.or differ diff --git a/lstech_maple/starexec_build b/lstech_maple/starexec_build new file mode 100755 index 0000000..01aa251 --- /dev/null +++ b/lstech_maple/starexec_build @@ -0,0 +1,9 @@ +#!/bin/sh +rm build/*.o build/*.or +rm build/libRelaxed.a +rm build/Relaxed +rm bin/lstech_maple +cd lstech/simp +make clean +make rs +cp glucose_static ../../bin/lstech_maple diff --git a/m4ri-20140914/.libs/libm4ri-0.0.20140914.so b/m4ri-20140914/.libs/libm4ri-0.0.20140914.so index 96cb723..23f9377 100755 Binary files a/m4ri-20140914/.libs/libm4ri-0.0.20140914.so and b/m4ri-20140914/.libs/libm4ri-0.0.20140914.so differ diff --git a/m4ri-20140914/.libs/libm4ri.a b/m4ri-20140914/.libs/libm4ri.a index 9462944..cba3f1f 100644 Binary files a/m4ri-20140914/.libs/libm4ri.a and b/m4ri-20140914/.libs/libm4ri.a differ diff --git a/m4ri-20140914/Makefile b/m4ri-20140914/Makefile index 4dd0d6c..b24060a 100644 --- a/m4ri-20140914/Makefile +++ b/m4ri-20140914/Makefile @@ -518,14 +518,14 @@ distuninstallcheck_listfiles = find . -type f -print am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' distcleancheck_listfiles = find . -type f -print -ACLOCAL = ${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14 +ACLOCAL = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14 AMTAR = $${TAR-tar} AM_DEFAULT_VERBOSITY = 1 AR = ar -AUTOCONF = ${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf -AUTOHEADER = ${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader -AUTOMAKE = ${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14 -AWK = mawk +AUTOCONF = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf +AUTOHEADER = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader +AUTOMAKE = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14 +AWK = gawk CC = gcc CCDEPMODE = depmode=gcc3 CFLAGS = -g -O2 @@ -560,8 +560,8 @@ LIPO = LN_S = ln -s LTLIBOBJS = M4RI_CPU_L1_CACHE = 32768 -M4RI_CPU_L2_CACHE = 1310720 -M4RI_CPU_L3_CACHE = 12582912 +M4RI_CPU_L2_CACHE = 524288 +M4RI_CPU_L3_CACHE = 33554432 M4RI_DEBUG_DUMP = 0 M4RI_DEBUG_MZD = 0 M4RI_HAVE_LIBPNG = 0 @@ -570,7 +570,7 @@ M4RI_HAVE_OPENMP = 0 M4RI_HAVE_POSIX_MEMALIGN = 1 M4RI_HAVE_SSE2 = 1 MAINT = # -MAKEINFO = ${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo +MAKEINFO = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo MANIFEST_TOOL = : MKDIR_P = /usr/bin/mkdir -p NM = /usr/bin/nm -B @@ -591,7 +591,7 @@ PAPI_CFLAGS = PAPI_LDFLAGS = PAPI_LIBS = PATH_SEPARATOR = : -PKG_CONFIG = +PKG_CONFIG = /usr/bin/pkg-config PKG_CONFIG_LIBDIR = PKG_CONFIG_PATH = PNG_CFLAGS = @@ -604,10 +604,10 @@ SHELL = /bin/bash SIMD_CFLAGS = -mmmx -msse -msse2 -msse3 STRIP = strip VERSION = 20140914 -abs_builddir = /root/cloud-sat/m4ri-20140914 -abs_srcdir = /root/cloud-sat/m4ri-20140914 -abs_top_builddir = /root/cloud-sat/m4ri-20140914 -abs_top_srcdir = /root/cloud-sat/m4ri-20140914 +abs_builddir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914 +abs_srcdir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914 +abs_top_builddir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914 +abs_top_srcdir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914 ac_ct_AR = ar ac_ct_CC = gcc ac_ct_DUMPBIN = @@ -636,7 +636,7 @@ host_vendor = unknown htmldir = ${docdir} includedir = ${prefix}/include infodir = ${datarootdir}/info -install_sh = ${SHELL} /root/cloud-sat/m4ri-20140914/install-sh +install_sh = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh libdir = ${exec_prefix}/lib libexecdir = ${exec_prefix}/libexec localedir = ${datarootdir}/locale diff --git a/m4ri-20140914/config.log b/m4ri-20140914/config.log index 197a8ca..cc8fc42 100644 --- a/m4ri-20140914/config.log +++ b/m4ri-20140914/config.log @@ -10,11 +10,11 @@ generated by GNU Autoconf 2.69. Invocation command line was ## Platform. ## ## --------- ## -hostname = code-server +hostname = seed7 uname -m = x86_64 -uname -r = 5.15.74-1-pve +uname -r = 5.4.0-121-generic uname -s = Linux -uname -v = #1 SMP PVE 5.15.74-1 (Mon, 14 Nov 2022 20:17:15 +0100) +uname -v = #137-Ubuntu SMP Wed Jun 15 13:33:07 UTC 2022 /usr/bin/uname -p = x86_64 /bin/uname -X = unknown @@ -27,209 +27,206 @@ uname -v = #1 SMP PVE 5.15.74-1 (Mon, 14 Nov 2022 20:17:15 +0100) /usr/bin/oslevel = unknown /bin/universe = unknown -PATH: /usr/lib/code-server/lib/vscode/bin/remote-cli PATH: /usr/local/sbin PATH: /usr/local/bin PATH: /usr/sbin PATH: /usr/bin PATH: /sbin PATH: /bin -PATH: /root/.local/bin +PATH: /usr/games +PATH: /usr/local/games +PATH: /snap/bin ## ----------- ## ## Core tests. ## ## ----------- ## -configure:2295: checking build system type -configure:2309: result: x86_64-unknown-linux-gnu -configure:2329: checking host system type -configure:2342: result: x86_64-unknown-linux-gnu -configure:2381: checking for a BSD-compatible install -configure:2449: result: /usr/bin/install -c -configure:2460: checking whether build environment is sane -configure:2515: result: yes -configure:2666: checking for a thread-safe mkdir -p -configure:2705: result: /usr/bin/mkdir -p -configure:2712: checking for gawk -configure:2742: result: no -configure:2712: checking for mawk -configure:2728: found /usr/bin/mawk -configure:2739: result: mawk -configure:2750: checking whether make sets $(MAKE) -configure:2772: result: yes -configure:2801: checking whether make supports nested variables -configure:2818: result: yes -configure:2946: checking whether to enable maintainer-specific portions of Makefiles -configure:2955: result: no -configure:2983: checking for style of include used by make -configure:3011: result: GNU -configure:3082: checking for gcc -configure:3098: found /usr/bin/gcc -configure:3109: result: gcc -configure:3338: checking for C compiler version -configure:3347: gcc --version >&5 -gcc (Ubuntu 12.2.0-3ubuntu1) 12.2.0 -Copyright (C) 2022 Free Software Foundation, Inc. +configure:2291: checking build system type +configure:2305: result: x86_64-unknown-linux-gnu +configure:2325: checking host system type +configure:2338: result: x86_64-unknown-linux-gnu +configure:2377: checking for a BSD-compatible install +configure:2445: result: /usr/bin/install -c +configure:2456: checking whether build environment is sane +configure:2511: result: yes +configure:2660: checking for a thread-safe mkdir -p +configure:2699: result: /usr/bin/mkdir -p +configure:2706: checking for gawk +configure:2722: found /usr/bin/gawk +configure:2733: result: gawk +configure:2744: checking whether make sets $(MAKE) +configure:2766: result: yes +configure:2795: checking whether make supports nested variables +configure:2812: result: yes +configure:2940: checking whether to enable maintainer-specific portions of Makefiles +configure:2949: result: no +configure:2977: checking for style of include used by make +configure:3005: result: GNU +configure:3076: checking for gcc +configure:3092: found /usr/bin/gcc +configure:3103: result: gcc +configure:3332: checking for C compiler version +configure:3341: gcc --version >&5 +gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0 +Copyright (C) 2019 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -configure:3358: $? = 0 -configure:3347: gcc -v >&5 +configure:3352: $? = 0 +configure:3341: gcc -v >&5 Using built-in specs. COLLECT_GCC=gcc -COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper -OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper +OFFLOAD_TARGET_NAMES=nvptx-none:hsa OFFLOAD_TARGET_DEFAULT=1 Target: x86_64-linux-gnu -Configured with: ../src/configure -v --with-pkgversion='Ubuntu 12.2.0-3ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-12/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-12 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-12-U8K4Qv/gcc-12-12.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-12-U8K4Qv/gcc-12-12.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu Thread model: posix -Supported LTO compression algorithms: zlib zstd -gcc version 12.2.0 (Ubuntu 12.2.0-3ubuntu1) -... rest of stderr output deleted ... -configure:3358: $? = 0 -configure:3347: gcc -V >&5 -gcc: error: unrecognized command-line option '-V' +gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1) +configure:3352: $? = 0 +configure:3341: gcc -V >&5 +gcc: error: unrecognized command line option '-V' gcc: fatal error: no input files compilation terminated. -configure:3358: $? = 1 -configure:3347: gcc -qversion >&5 -gcc: error: unrecognized command-line option '-qversion'; did you mean '--version'? +configure:3352: $? = 1 +configure:3341: gcc -qversion >&5 +gcc: error: unrecognized command line option '-qversion'; did you mean '--version'? gcc: fatal error: no input files compilation terminated. -configure:3358: $? = 1 -configure:3378: checking whether the C compiler works -configure:3400: gcc conftest.c >&5 -configure:3404: $? = 0 -configure:3452: result: yes -configure:3455: checking for C compiler default output file name -configure:3457: result: a.out -configure:3463: checking for suffix of executables -configure:3470: gcc -o conftest conftest.c >&5 -configure:3474: $? = 0 -configure:3496: result: -configure:3518: checking whether we are cross compiling -configure:3526: gcc -o conftest conftest.c >&5 -configure:3530: $? = 0 -configure:3537: ./conftest -configure:3541: $? = 0 -configure:3556: result: no -configure:3561: checking for suffix of object files -configure:3583: gcc -c conftest.c >&5 -configure:3587: $? = 0 -configure:3608: result: o -configure:3612: checking whether we are using the GNU C compiler -configure:3631: gcc -c conftest.c >&5 -configure:3631: $? = 0 -configure:3640: result: yes -configure:3649: checking whether gcc accepts -g -configure:3669: gcc -c -g conftest.c >&5 -configure:3669: $? = 0 -configure:3710: result: yes -configure:3727: checking for gcc option to accept ISO C89 -configure:3790: gcc -c -g -O2 conftest.c >&5 -configure:3790: $? = 0 -configure:3803: result: none needed -configure:3828: checking whether gcc understands -c and -o together -configure:3850: gcc -c conftest.c -o conftest2.o -configure:3853: $? = 0 -configure:3850: gcc -c conftest.c -o conftest2.o -configure:3853: $? = 0 -configure:3865: result: yes -configure:3884: checking dependency style of gcc -configure:3995: result: gcc3 -configure:4058: checking how to print strings -configure:4085: result: printf -configure:4106: checking for a sed that does not truncate output -configure:4170: result: /usr/bin/sed -configure:4188: checking for grep that handles long lines and -e -configure:4246: result: /usr/bin/grep -configure:4251: checking for egrep -configure:4313: result: /usr/bin/grep -E -configure:4318: checking for fgrep -configure:4380: result: /usr/bin/grep -F -configure:4415: checking for ld used by gcc -configure:4482: result: /usr/bin/ld -configure:4489: checking if the linker (/usr/bin/ld) is GNU ld -configure:4504: result: yes -configure:4516: checking for BSD- or MS-compatible name lister (nm) -configure:4565: result: /usr/bin/nm -B -configure:4695: checking the name lister (/usr/bin/nm -B) interface -configure:4702: gcc -c -g -O2 conftest.c >&5 -configure:4705: /usr/bin/nm -B "conftest.o" -configure:4708: output +configure:3352: $? = 1 +configure:3372: checking whether the C compiler works +configure:3394: gcc conftest.c >&5 +configure:3398: $? = 0 +configure:3446: result: yes +configure:3449: checking for C compiler default output file name +configure:3451: result: a.out +configure:3457: checking for suffix of executables +configure:3464: gcc -o conftest conftest.c >&5 +configure:3468: $? = 0 +configure:3490: result: +configure:3512: checking whether we are cross compiling +configure:3520: gcc -o conftest conftest.c >&5 +configure:3524: $? = 0 +configure:3531: ./conftest +configure:3535: $? = 0 +configure:3523: result: no +configure:3528: checking for suffix of object files +configure:3550: gcc -c conftest.c >&5 +configure:3554: $? = 0 +configure:3575: result: o +configure:3579: checking whether we are using the GNU C compiler +configure:3598: gcc -c conftest.c >&5 +configure:3598: $? = 0 +configure:3607: result: yes +configure:3616: checking whether gcc accepts -g +configure:3636: gcc -c -g conftest.c >&5 +configure:3636: $? = 0 +configure:3677: result: yes +configure:3694: checking for gcc option to accept ISO C89 +configure:3757: gcc -c -g -O2 conftest.c >&5 +configure:3757: $? = 0 +configure:3770: result: none needed +configure:3795: checking whether gcc understands -c and -o together +configure:3817: gcc -c conftest.c -o conftest2.o +configure:3820: $? = 0 +configure:3817: gcc -c conftest.c -o conftest2.o +configure:3820: $? = 0 +configure:3832: result: yes +configure:3851: checking dependency style of gcc +configure:3962: result: gcc3 +configure:4025: checking how to print strings +configure:4052: result: printf +configure:4073: checking for a sed that does not truncate output +configure:4137: result: /usr/bin/sed +configure:4155: checking for grep that handles long lines and -e +configure:4213: result: /usr/bin/grep +configure:4218: checking for egrep +configure:4280: result: /usr/bin/grep -E +configure:4285: checking for fgrep +configure:4347: result: /usr/bin/grep -F +configure:4382: checking for ld used by gcc +configure:4449: result: /usr/bin/ld +configure:4456: checking if the linker (/usr/bin/ld) is GNU ld +configure:4471: result: yes +configure:4483: checking for BSD- or MS-compatible name lister (nm) +configure:4532: result: /usr/bin/nm -B +configure:4662: checking the name lister (/usr/bin/nm -B) interface +configure:4669: gcc -c -g -O2 conftest.c >&5 +configure:4672: /usr/bin/nm -B "conftest.o" +configure:4675: output 0000000000000000 B some_variable -configure:4715: result: BSD nm -configure:4718: checking whether ln -s works -configure:4722: result: yes -configure:4730: checking the maximum length of command line arguments -configure:4861: result: 1572864 -configure:4878: checking whether the shell understands some XSI constructs -configure:4888: result: yes -configure:4892: checking whether the shell understands "+=" -configure:4898: result: yes -configure:4933: checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format -configure:4973: result: func_convert_file_noop -configure:4980: checking how to convert x86_64-unknown-linux-gnu file names to toolchain format -configure:5000: result: func_convert_file_noop -configure:5007: checking for /usr/bin/ld option to reload object files -configure:5014: result: -r -configure:5088: checking for objdump -configure:5104: found /usr/bin/objdump -configure:5115: result: objdump -configure:5147: checking how to recognize dependent libraries -configure:5345: result: pass_all -configure:5430: checking for dlltool -configure:5460: result: no -configure:5490: checking how to associate runtime and link libraries -configure:5517: result: printf %s\n -configure:5578: checking for ar -configure:5594: found /usr/bin/ar -configure:5605: result: ar -configure:5642: checking for archiver @FILE support -configure:5659: gcc -c -g -O2 conftest.c >&5 -configure:5659: $? = 0 -configure:5662: ar cru libconftest.a @conftest.lst >&5 +configure:4676: result: BSD nm +configure:4679: checking whether ln -s works +configure:4683: result: yes +configure:4691: checking the maximum length of command line arguments +configure:4822: result: 1572864 +configure:4839: checking whether the shell understands some XSI constructs +configure:4848: result: yes +configure:4852: checking whether the shell understands "+=" +configure:4856: result: yes +configure:4891: checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format +configure:4931: result: func_convert_file_noop +configure:4938: checking how to convert x86_64-unknown-linux-gnu file names to toolchain format +configure:4958: result: func_convert_file_noop +configure:4965: checking for /usr/bin/ld option to reload object files +configure:4972: result: -r +configure:5046: checking for objdump +configure:5062: found /usr/bin/objdump +configure:5073: result: objdump +configure:5105: checking how to recognize dependent libraries +configure:5303: result: pass_all +configure:5388: checking for dlltool +configure:5418: result: no +configure:5448: checking how to associate runtime and link libraries +configure:5475: result: printf %s\n +configure:5536: checking for ar +configure:5552: found /usr/bin/ar +configure:5563: result: ar +configure:5600: checking for archiver @FILE support +configure:5617: gcc -c -g -O2 conftest.c >&5 +configure:5617: $? = 0 +configure:5620: ar cru libconftest.a @conftest.lst >&5 ar: `u' modifier ignored since `D' is the default (see `U') -configure:5665: $? = 0 -configure:5670: ar cru libconftest.a @conftest.lst >&5 +configure:5623: $? = 0 +configure:5628: ar cru libconftest.a @conftest.lst >&5 ar: `u' modifier ignored since `D' is the default (see `U') ar: conftest.o: No such file or directory -configure:5673: $? = 1 -configure:5685: result: @ -configure:5743: checking for strip -configure:5759: found /usr/bin/strip -configure:5770: result: strip -configure:5842: checking for ranlib -configure:5858: found /usr/bin/ranlib -configure:5869: result: ranlib -configure:5971: checking command to parse /usr/bin/nm -B output from gcc object -configure:6091: gcc -c -g -O2 conftest.c >&5 -configure:6094: $? = 0 -configure:6098: /usr/bin/nm -B conftest.o \| sed -n -e 's/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' | sed '/ __gnu_lto/d' \> conftest.nm -configure:6101: $? = 0 -configure:6167: gcc -o conftest -g -O2 conftest.c conftstm.o >&5 -configure:6170: $? = 0 -configure:6208: result: ok -configure:6245: checking for sysroot -configure:6275: result: no -configure:6352: gcc -c -g -O2 conftest.c >&5 -configure:6355: $? = 0 -configure:6544: checking for mt -configure:6560: found /usr/bin/mt -configure:6571: result: mt -configure:6594: checking if mt is a manifest tool -configure:6600: mt '-?' -configure:6608: result: no -configure:7250: checking how to run the C preprocessor -configure:7281: gcc -E conftest.c -configure:7281: $? = 0 -configure:7295: gcc -E conftest.c +configure:5631: $? = 1 +configure:5630: result: @ +configure:5688: checking for strip +configure:5704: found /usr/bin/strip +configure:5715: result: strip +configure:5787: checking for ranlib +configure:5803: found /usr/bin/ranlib +configure:5814: result: ranlib +configure:5916: checking command to parse /usr/bin/nm -B output from gcc object +configure:6036: gcc -c -g -O2 conftest.c >&5 +configure:6039: $? = 0 +configure:6043: /usr/bin/nm -B conftest.o \| sed -n -e 's/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' | sed '/ __gnu_lto/d' \> conftest.nm +configure:6046: $? = 0 +configure:6112: gcc -o conftest -g -O2 conftest.c conftstm.o >&5 +configure:6115: $? = 0 +configure:6153: result: ok +configure:6190: checking for sysroot +configure:6220: result: no +configure:6297: gcc -c -g -O2 conftest.c >&5 +configure:6300: $? = 0 +configure:6489: checking for mt +configure:6505: found /usr/bin/mt +configure:6516: result: mt +configure:6539: checking if mt is a manifest tool +configure:6545: mt '-?' +configure:6553: result: no +configure:7195: checking how to run the C preprocessor +configure:7226: gcc -E conftest.c +configure:7226: $? = 0 +configure:7240: gcc -E conftest.c conftest.c:11:10: fatal error: ac_nonexistent.h: No such file or directory 11 | #include | ^~~~~~~~~~~~~~~~~~ compilation terminated. -configure:7295: $? = 1 +configure:7240: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -242,15 +239,15 @@ configure: failed program was: | #define VERSION "20140914" | /* end confdefs.h. */ | #include -configure:7320: result: gcc -E -configure:7340: gcc -E conftest.c -configure:7340: $? = 0 -configure:7354: gcc -E conftest.c +configure:7265: result: gcc -E +configure:7285: gcc -E conftest.c +configure:7285: $? = 0 +configure:7299: gcc -E conftest.c conftest.c:11:10: fatal error: ac_nonexistent.h: No such file or directory 11 | #include | ^~~~~~~~~~~~~~~~~~ compilation terminated. -configure:7354: $? = 1 +configure:7299: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -263,154 +260,154 @@ configure: failed program was: | #define VERSION "20140914" | /* end confdefs.h. */ | #include -configure:7383: checking for ANSI C header files -configure:7403: gcc -c -g -O2 conftest.c >&5 -configure:7403: $? = 0 -configure:7476: gcc -o conftest -g -O2 conftest.c >&5 -configure:7476: $? = 0 -configure:7476: ./conftest -configure:7476: $? = 0 -configure:7487: result: yes -configure:7500: checking for sys/types.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for sys/stat.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for stdlib.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for string.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for memory.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for strings.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for inttypes.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for stdint.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7500: checking for unistd.h -configure:7500: gcc -c -g -O2 conftest.c >&5 -configure:7500: $? = 0 -configure:7500: result: yes -configure:7514: checking for dlfcn.h -configure:7514: gcc -c -g -O2 conftest.c >&5 -configure:7514: $? = 0 -configure:7514: result: yes -configure:7720: checking for objdir -configure:7735: result: .libs -configure:8006: checking if gcc supports -fno-rtti -fno-exceptions -configure:8024: gcc -c -g -O2 -fno-rtti -fno-exceptions conftest.c >&5 -cc1: warning: command-line option '-fno-rtti' is valid for C++/D/ObjC++ but not for C -configure:8028: $? = 0 -configure:8041: result: no -configure:8368: checking for gcc option to produce PIC -configure:8375: result: -fPIC -DPIC -configure:8383: checking if gcc PIC flag -fPIC -DPIC works -configure:8401: gcc -c -g -O2 -fPIC -DPIC -DPIC conftest.c >&5 -configure:8405: $? = 0 -configure:8418: result: yes -configure:8447: checking if gcc static flag -static works -configure:8475: result: yes +configure:7328: checking for ANSI C header files +configure:7348: gcc -c -g -O2 conftest.c >&5 +configure:7348: $? = 0 +configure:7421: gcc -o conftest -g -O2 conftest.c >&5 +configure:7421: $? = 0 +configure:7421: ./conftest +configure:7421: $? = 0 +configure:7432: result: yes +configure:7445: checking for sys/types.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for sys/stat.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for stdlib.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for string.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for memory.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for strings.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for inttypes.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for stdint.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7445: checking for unistd.h +configure:7445: gcc -c -g -O2 conftest.c >&5 +configure:7445: $? = 0 +configure:7445: result: yes +configure:7459: checking for dlfcn.h +configure:7459: gcc -c -g -O2 conftest.c >&5 +configure:7459: $? = 0 +configure:7459: result: yes +configure:7665: checking for objdir +configure:7680: result: .libs +configure:7951: checking if gcc supports -fno-rtti -fno-exceptions +configure:7969: gcc -c -g -O2 -fno-rtti -fno-exceptions conftest.c >&5 +cc1: warning: command line option '-fno-rtti' is valid for C++/D/ObjC++ but not for C +configure:7973: $? = 0 +configure:7986: result: no +configure:8313: checking for gcc option to produce PIC +configure:8320: result: -fPIC -DPIC +configure:8328: checking if gcc PIC flag -fPIC -DPIC works +configure:8346: gcc -c -g -O2 -fPIC -DPIC -DPIC conftest.c >&5 +configure:8350: $? = 0 +configure:8363: result: yes +configure:8392: checking if gcc static flag -static works +configure:8420: result: yes +configure:8435: checking if gcc supports -c -o file.o +configure:8456: gcc -c -g -O2 -o out/conftest2.o conftest.c >&5 +configure:8460: $? = 0 +configure:8482: result: yes configure:8490: checking if gcc supports -c -o file.o -configure:8511: gcc -c -g -O2 -o out/conftest2.o conftest.c >&5 -configure:8515: $? = 0 configure:8537: result: yes -configure:8545: checking if gcc supports -c -o file.o -configure:8592: result: yes -configure:8625: checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries -configure:9782: result: yes -configure:9819: checking whether -lc should be explicitly linked in -configure:9827: gcc -c -g -O2 conftest.c >&5 -configure:9830: $? = 0 -configure:9845: gcc -shared -fPIC -DPIC conftest.o -v -Wl,-soname -Wl,conftest -o conftest 2\>\&1 \| /usr/bin/grep -lc \>/dev/null 2\>\&1 -configure:9848: $? = 0 -configure:9862: result: no -configure:10022: checking dynamic linker characteristics -configure:10522: gcc -o conftest -g -O2 -Wl,-rpath -Wl,/foo conftest.c >&5 -configure:10522: $? = 0 -configure:10756: result: GNU/Linux ld.so -configure:10863: checking how to hardcode library paths into programs -configure:10888: result: immediate -configure:11428: checking whether stripping libraries is possible -configure:11433: result: yes -configure:11468: checking if libtool supports shared libraries -configure:11470: result: yes -configure:11473: checking whether to build shared libraries -configure:11494: result: yes -configure:11497: checking whether to build static libraries -configure:11501: result: yes -configure:11544: checking for gcc option to accept ISO C99 -configure:11693: gcc -c -g -O2 conftest.c >&5 -configure:11693: $? = 0 -configure:11706: result: none needed -configure:11750: checking for x86 cpuid 0x00000001 output -configure:11789: gcc -o conftest -g -O2 conftest.c >&5 -configure:11789: $? = 0 -configure:11789: ./conftest -configure:11789: $? = 0 -configure:11799: result: 90675:7100800:7ffafbbf:bfebfbff -configure:11811: checking whether mmx is supported -configure:11823: result: yes -configure:11826: checking whether sse is supported -configure:11838: result: yes -configure:11841: checking whether sse2 is supported -configure:11853: result: yes -configure:11856: checking whether sse3 is supported -configure:11868: result: yes -configure:11871: checking whether ssse3 is supported -configure:11883: result: yes -configure:11890: checking whether C compiler accepts -mmmx -configure:11909: gcc -c -mmmx conftest.c >&5 -configure:11909: $? = 0 -configure:11919: result: yes -configure:11933: checking whether C compiler accepts -msse -configure:11952: gcc -c -msse conftest.c >&5 -configure:11952: $? = 0 -configure:11962: result: yes -configure:11976: checking whether C compiler accepts -msse2 -configure:11995: gcc -c -msse2 conftest.c >&5 -configure:11995: $? = 0 -configure:12005: result: yes -configure:12019: checking whether C compiler accepts -msse3 -configure:12038: gcc -c -msse3 conftest.c >&5 -configure:12038: $? = 0 -configure:12048: result: yes -configure:12091: checking mm_malloc.h usability -configure:12091: gcc -c -g -O2 conftest.c >&5 -configure:12091: $? = 0 -configure:12091: result: yes -configure:12091: checking mm_malloc.h presence -configure:12091: gcc -E conftest.c -configure:12091: $? = 0 -configure:12091: result: yes -configure:12091: checking for mm_malloc.h -configure:12091: result: yes -configure:12107: checking for working posix_memalign -configure:12131: gcc -o conftest -g -O2 conftest.c >&5 -configure:12131: $? = 0 -configure:12131: ./conftest -configure:12131: $? = 0 -configure:12141: result: yes -configure:12282: checking for PAPI_start_counters in -lpapi -configure:12307: gcc -o conftest -g -O2 conftest.c -lpapi >&5 -/usr/bin/ld: cannot find -lpapi: No such file or directory +configure:8570: checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries +configure:9727: result: yes +configure:9764: checking whether -lc should be explicitly linked in +configure:9772: gcc -c -g -O2 conftest.c >&5 +configure:9775: $? = 0 +configure:9790: gcc -shared -fPIC -DPIC conftest.o -v -Wl,-soname -Wl,conftest -o conftest 2\>\&1 \| /usr/bin/grep -lc \>/dev/null 2\>\&1 +configure:9793: $? = 0 +configure:9807: result: no +configure:9967: checking dynamic linker characteristics +configure:10467: gcc -o conftest -g -O2 -Wl,-rpath -Wl,/foo conftest.c >&5 +configure:10467: $? = 0 +configure:10701: result: GNU/Linux ld.so +configure:10808: checking how to hardcode library paths into programs +configure:10833: result: immediate +configure:11373: checking whether stripping libraries is possible +configure:11378: result: yes +configure:11413: checking if libtool supports shared libraries +configure:11415: result: yes +configure:11418: checking whether to build shared libraries +configure:11439: result: yes +configure:11442: checking whether to build static libraries +configure:11446: result: yes +configure:8494: checking for gcc option to accept ISO C99 +configure:8643: gcc -c -g -O2 conftest.c >&5 +configure:8643: $? = 0 +configure:8656: result: none needed +configure:8700: checking for x86 cpuid 0x00000001 output +configure:8739: gcc -o conftest -g -O2 conftest.c >&5 +configure:8739: $? = 0 +configure:8739: ./conftest +configure:8739: $? = 0 +configure:8749: result: a00f11:5e800800:7efa320b:178bfbff +configure:8761: checking whether mmx is supported +configure:8773: result: yes +configure:8776: checking whether sse is supported +configure:8788: result: yes +configure:8791: checking whether sse2 is supported +configure:8803: result: yes +configure:8806: checking whether sse3 is supported +configure:8818: result: yes +configure:8821: checking whether ssse3 is supported +configure:8833: result: yes +configure:8840: checking whether C compiler accepts -mmmx +configure:8859: gcc -c -mmmx conftest.c >&5 +configure:8859: $? = 0 +configure:8869: result: yes +configure:8883: checking whether C compiler accepts -msse +configure:8902: gcc -c -msse conftest.c >&5 +configure:8902: $? = 0 +configure:8912: result: yes +configure:8926: checking whether C compiler accepts -msse2 +configure:8945: gcc -c -msse2 conftest.c >&5 +configure:8945: $? = 0 +configure:8955: result: yes +configure:8969: checking whether C compiler accepts -msse3 +configure:8988: gcc -c -msse3 conftest.c >&5 +configure:8988: $? = 0 +configure:8998: result: yes +configure:9041: checking mm_malloc.h usability +configure:9041: gcc -c -g -O2 conftest.c >&5 +configure:9041: $? = 0 +configure:9041: result: yes +configure:9041: checking mm_malloc.h presence +configure:9041: gcc -E conftest.c +configure:9041: $? = 0 +configure:9041: result: yes +configure:9041: checking for mm_malloc.h +configure:9041: result: yes +configure:9057: checking for working posix_memalign +configure:9081: gcc -o conftest -g -O2 conftest.c >&5 +configure:9081: $? = 0 +configure:9081: ./conftest +configure:9081: $? = 0 +configure:9091: result: yes +configure:9232: checking for PAPI_start_counters in -lpapi +configure:9257: gcc -o conftest -g -O2 conftest.c -lpapi >&5 +/usr/bin/ld: cannot find -lpapi collect2: error: ld returned 1 exit status -configure:12307: $? = 1 +configure:9257: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -457,36 +454,52 @@ configure: failed program was: | ; | return 0; | } -configure:12316: result: no -configure:12486: checking for x86 cpuid 0x0 output -configure:12525: gcc -o conftest -g -O2 conftest.c >&5 -configure:12525: $? = 0 -configure:12525: ./conftest -configure:12525: $? = 0 -configure:12535: result: 20:756e6547:6c65746e:49656e69 -configure:12545: checking for the processor vendor -configure:12584: result: Intel -configure:12601: checking for x86 cpuid 0x0 output -configure:12650: result: 20:756e6547:6c65746e:49656e69 -configure:12660: checking for the processor vendor -configure:12699: result: Intel -configure:13036: checking the L1 cache size -configure:13040: result: 32768 Bytes -configure:13043: checking the L2 cache size -configure:13047: result: 1310720 Bytes -configure:13050: checking the L3 cache size -configure:13054: result: 12582912 Bytes -configure:13315: checking whether to build with PNG support -configure:13317: result: yes -configure:13375: checking for pkg-config -configure:13408: result: no -configure:13443: checking for PNG -configure:13502: result: no -configure:13513: checking for png_create_write_struct in -lpng -configure:13538: gcc -o conftest -g -O2 conftest.c -lpng >&5 -/usr/bin/ld: cannot find -lpng: No such file or directory +configure:9266: result: no +configure:9436: checking for x86 cpuid 0x0 output +configure:9475: gcc -o conftest -g -O2 conftest.c >&5 +configure:9475: $? = 0 +configure:9475: ./conftest +configure:9475: $? = 0 +configure:9485: result: 10:68747541:444d4163:69746e65 +configure:9495: checking for the processor vendor +configure:9534: result: AMD +configure:9551: checking for x86 cpuid 0x0 output +configure:9600: result: 10:68747541:444d4163:69746e65 +configure:9610: checking for the processor vendor +configure:9649: result: AMD +configure:9986: checking the L1 cache size +configure:9990: result: 32768 Bytes +configure:9993: checking the L2 cache size +configure:9997: result: 524288 Bytes +configure:10000: checking the L3 cache size +configure:10004: result: 33554432 Bytes +configure:10265: checking whether to build with PNG support +configure:10267: result: yes +configure:10325: checking for pkg-config +configure:10343: found /usr/bin/pkg-config +configure:10355: result: /usr/bin/pkg-config +configure:10380: checking pkg-config is at least version 0.9.0 +configure:10383: result: yes +configure:10393: checking for PNG +configure:10400: $PKG_CONFIG --exists --print-errors "libpng" +Package libpng was not found in the pkg-config search path. +Perhaps you should add the directory containing `libpng.pc' +to the PKG_CONFIG_PATH environment variable +No package 'libpng' found +configure:10403: $? = 1 +configure:10417: $PKG_CONFIG --exists --print-errors "libpng" +Package libpng was not found in the pkg-config search path. +Perhaps you should add the directory containing `libpng.pc' +to the PKG_CONFIG_PATH environment variable +No package 'libpng' found +configure:10420: $? = 1 +configure:10434: result: no +No package 'libpng' found +configure:10463: checking for png_create_write_struct in -lpng +configure:10488: gcc -o conftest -g -O2 conftest.c -lpng >&5 +/usr/bin/ld: cannot find -lpng collect2: error: ld returned 1 exit status -configure:13538: $? = 1 +configure:10488: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -533,12 +546,12 @@ configure: failed program was: | ; | return 0; | } -configure:13547: result: no -configure:13552: checking for png_create_write_struct in -lpng14 -configure:13577: gcc -o conftest -g -O2 conftest.c -lpng14 >&5 -/usr/bin/ld: cannot find -lpng14: No such file or directory +configure:10497: result: no +configure:10502: checking for png_create_write_struct in -lpng14 +configure:10527: gcc -o conftest -g -O2 conftest.c -lpng14 >&5 +/usr/bin/ld: cannot find -lpng14 collect2: error: ld returned 1 exit status -configure:13577: $? = 1 +configure:10527: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -585,12 +598,12 @@ configure: failed program was: | ; | return 0; | } -configure:13586: result: no -configure:13591: checking for png_create_write_struct in -lpng12 -configure:13616: gcc -o conftest -g -O2 conftest.c -lpng12 >&5 -/usr/bin/ld: cannot find -lpng12: No such file or directory +configure:10536: result: no +configure:10541: checking for png_create_write_struct in -lpng12 +configure:10566: gcc -o conftest -g -O2 conftest.c -lpng12 >&5 +/usr/bin/ld: cannot find -lpng12 collect2: error: ld returned 1 exit status -configure:13616: $? = 1 +configure:10566: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -637,12 +650,12 @@ configure: failed program was: | ; | return 0; | } -configure:13625: result: no -configure:13630: checking for png_create_write_struct in -lpng10 -configure:13655: gcc -o conftest -g -O2 conftest.c -lpng10 >&5 -/usr/bin/ld: cannot find -lpng10: No such file or directory +configure:10575: result: no +configure:10580: checking for png_create_write_struct in -lpng10 +configure:10605: gcc -o conftest -g -O2 conftest.c -lpng10 >&5 +/usr/bin/ld: cannot find -lpng10 collect2: error: ld returned 1 exit status -configure:13655: $? = 1 +configure:10605: $? = 1 configure: failed program was: | /* confdefs.h */ | #define PACKAGE_NAME "m4ri" @@ -689,13 +702,13 @@ configure: failed program was: | ; | return 0; | } -configure:13664: result: no -configure:13683: WARNING: Can not find a usuable PNG library. Make sure that CPPFLAGS and LDFLAGS are correctly set. -configure:13700: checking whether make sets $(MAKE) -configure:13722: result: yes -configure:13835: checking that generated files are newer than configure -configure:13841: result: done -configure:13868: creating ./config.status +configure:10614: result: no +configure:10633: WARNING: Can not find a usuable PNG library. Make sure that CPPFLAGS and LDFLAGS are correctly set. +configure:10650: checking whether make sets $(MAKE) +configure:10672: result: yes +configure:10785: checking that generated files are newer than configure +configure:10791: result: done +configure:10818: creating ./config.status ## ---------------- ## ## Cache variables. ## @@ -754,9 +767,10 @@ ac_cv_path_EGREP='/usr/bin/grep -E' ac_cv_path_FGREP='/usr/bin/grep -F' ac_cv_path_GREP=/usr/bin/grep ac_cv_path_SED=/usr/bin/sed +ac_cv_path_ac_pt_PKG_CONFIG=/usr/bin/pkg-config ac_cv_path_install='/usr/bin/install -c' ac_cv_path_mkdir=/usr/bin/mkdir -ac_cv_prog_AWK=mawk +ac_cv_prog_AWK=gawk ac_cv_prog_CPP='gcc -E' ac_cv_prog_ac_ct_AR=ar ac_cv_prog_ac_ct_CC=gcc @@ -775,10 +789,10 @@ ax_cv_c_flags__mmmx=yes ax_cv_c_flags__msse2=yes ax_cv_c_flags__msse3=yes ax_cv_c_flags__msse=yes -ax_cv_cpu_vendor=Intel +ax_cv_cpu_vendor=AMD ax_cv_func_posix_memalign_works=yes -ax_cv_gcc_x86_cpuid_0x00000001=90675:7100800:7ffafbbf:bfebfbff -ax_cv_gcc_x86_cpuid_0x0=20:756e6547:6c65746e:49656e69 +ax_cv_gcc_x86_cpuid_0x00000001=a00f11:5e800800:7efa320b:178bfbff +ax_cv_gcc_x86_cpuid_0x0=10:68747541:444d4163:69746e65 ax_cv_have_mmx_ext=yes ax_cv_have_sse2_ext=yes ax_cv_have_sse3_ext=yes @@ -815,7 +829,7 @@ lt_cv_to_tool_file_cmd=func_convert_file_noop ## Output variables. ## ## ----------------- ## -ACLOCAL='${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14' +ACLOCAL='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14' AMDEPBACKSLASH='\' AMDEP_FALSE='#' AMDEP_TRUE='' @@ -825,10 +839,10 @@ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' AM_DEFAULT_VERBOSITY='1' AM_V='$(V)' AR='ar' -AUTOCONF='${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf' -AUTOHEADER='${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader' -AUTOMAKE='${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14' -AWK='mawk' +AUTOCONF='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf' +AUTOHEADER='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader' +AUTOMAKE='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14' +AWK='gawk' CC='gcc' CCDEPMODE='depmode=gcc3' CFLAGS='-g -O2' @@ -862,8 +876,8 @@ LIPO='' LN_S='ln -s' LTLIBOBJS='' M4RI_CPU_L1_CACHE='32768' -M4RI_CPU_L2_CACHE='1310720' -M4RI_CPU_L3_CACHE='12582912' +M4RI_CPU_L2_CACHE='524288' +M4RI_CPU_L3_CACHE='33554432' M4RI_DEBUG_DUMP='0' M4RI_DEBUG_MZD='0' M4RI_HAVE_LIBPNG='0' @@ -874,7 +888,7 @@ M4RI_HAVE_SSE2='1' MAINT='#' MAINTAINER_MODE_FALSE='' MAINTAINER_MODE_TRUE='#' -MAKEINFO='${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo' +MAKEINFO='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo' MANIFEST_TOOL=':' MKDIR_P='/usr/bin/mkdir -p' NM='/usr/bin/nm -B' @@ -895,7 +909,7 @@ PAPI_CFLAGS='' PAPI_LDFLAGS='' PAPI_LIBS='' PATH_SEPARATOR=':' -PKG_CONFIG='' +PKG_CONFIG='/usr/bin/pkg-config' PKG_CONFIG_LIBDIR='' PKG_CONFIG_PATH='' PNG_CFLAGS='' @@ -941,7 +955,7 @@ host_vendor='unknown' htmldir='${docdir}' includedir='${prefix}/include' infodir='${datarootdir}/info' -install_sh='${SHELL} /root/cloud-sat/m4ri-20140914/install-sh' +install_sh='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh' libdir='${exec_prefix}/lib' libexecdir='${exec_prefix}/libexec' localedir='${datarootdir}/locale' @@ -1007,13 +1021,13 @@ generated by GNU Autoconf 2.69. Invocation command line was CONFIG_COMMANDS = $ ./config.status -on code-server +on seed7 -config.status:1117: creating Makefile -config.status:1117: creating testsuite/Makefile -config.status:1117: creating m4ri/m4ri_config.h -config.status:1117: creating m4ri.pc -config.status:1117: creating m4ri/config.h -config.status:1298: m4ri/config.h is unchanged -config.status:1346: executing depfiles commands -config.status:1346: executing libtool commands +config.status:1113: creating Makefile +config.status:1113: creating testsuite/Makefile +config.status:1113: creating m4ri/m4ri_config.h +config.status:1113: creating m4ri.pc +config.status:1113: creating m4ri/config.h +config.status:1294: m4ri/config.h is unchanged +config.status:1342: executing depfiles commands +config.status:1342: executing libtool commands diff --git a/m4ri-20140914/config.status b/m4ri-20140914/config.status index 1b7aab2..2ab8a50 100755 --- a/m4ri-20140914/config.status +++ b/m4ri-20140914/config.status @@ -437,11 +437,11 @@ Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." -ac_pwd='/root/cloud-sat/m4ri-20140914' +ac_pwd='/home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914' srcdir='.' INSTALL='/usr/bin/install -c' MKDIR_P='/usr/bin/mkdir -p' -AWK='mawk' +AWK='gawk' test -n "$AWK" || AWK=awk # The default lists apply if the user does not specify any file. ac_need_defaults=: @@ -674,8 +674,8 @@ postuninstall_cmds='' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' finish_eval='' hardcode_into_libs='yes' -sys_lib_search_path_spec='/usr/lib/gcc/x86_64-linux-gnu/12 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib ' -sys_lib_dlsearch_path_spec='/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu /lib32 /usr/lib32 ' +sys_lib_search_path_spec='/usr/lib/gcc/x86_64-linux-gnu/9 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib ' +sys_lib_dlsearch_path_spec='/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu ' hardcode_action='immediate' enable_dlopen='unknown' enable_dlopen_self='unknown' @@ -827,9 +827,9 @@ S["PNG_LIBS"]="" S["PNG_CFLAGS"]="" S["PKG_CONFIG_LIBDIR"]="" S["PKG_CONFIG_PATH"]="" -S["PKG_CONFIG"]="" -S["M4RI_CPU_L3_CACHE"]="12582912" -S["M4RI_CPU_L2_CACHE"]="1310720" +S["PKG_CONFIG"]="/usr/bin/pkg-config" +S["M4RI_CPU_L3_CACHE"]="33554432" +S["M4RI_CPU_L2_CACHE"]="524288" S["M4RI_CPU_L1_CACHE"]="32768" S["PAPI_CFLAGS"]="" S["PAPI_LDFLAGS"]="" @@ -894,17 +894,17 @@ S["am__tar"]="$${TAR-tar} chof - \"$$tardir\"" S["AMTAR"]="$${TAR-tar}" S["am__leading_dot"]="." S["SET_MAKE"]="" -S["AWK"]="mawk" +S["AWK"]="gawk" S["mkdir_p"]="$(MKDIR_P)" S["MKDIR_P"]="/usr/bin/mkdir -p" S["INSTALL_STRIP_PROGRAM"]="$(install_sh) -c -s" S["STRIP"]="strip" -S["install_sh"]="${SHELL} /root/cloud-sat/m4ri-20140914/install-sh" -S["MAKEINFO"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo" -S["AUTOHEADER"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader" -S["AUTOMAKE"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14" -S["AUTOCONF"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf" -S["ACLOCAL"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14" +S["install_sh"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh" +S["MAKEINFO"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo" +S["AUTOHEADER"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader" +S["AUTOMAKE"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14" +S["AUTOCONF"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf" +S["ACLOCAL"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14" S["VERSION"]="20140914" S["PACKAGE"]="m4ri" S["CYGPATH_W"]="echo" diff --git a/m4ri-20140914/libtool b/m4ri-20140914/libtool index 6cbf04d..37c7bdd 100755 --- a/m4ri-20140914/libtool +++ b/m4ri-20140914/libtool @@ -2,7 +2,7 @@ # libtool - Provide generalized library-building support services. # Generated automatically by config.status (m4ri) 20140914 -# Libtool was configured on host code-server: +# Libtool was configured on host seed7: # NOTE: Changes made to this file will be lost: look at ltmain.sh. # # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, @@ -272,10 +272,10 @@ finish_eval="" hardcode_into_libs=yes # Compile-time system search path for libraries. -sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/12 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib " +sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/9 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib " # Run-time system search path for libraries. -sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu /lib32 /usr/lib32 " +sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu " # Whether dlopen is supported. dlopen_support=unknown diff --git a/m4ri-20140914/m4ri/.deps/brilliantrussian.Plo b/m4ri-20140914/m4ri/.deps/brilliantrussian.Plo index 824771e..bbd802d 100644 --- a/m4ri-20140914/m4ri/.deps/brilliantrussian.Plo +++ b/m4ri-20140914/m4ri/.deps/brilliantrussian.Plo @@ -2,14 +2,13 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \ /usr/include/stdc-predef.h m4ri/config.h m4ri/brilliantrussian.h \ /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,8 +19,9 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/string.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/string.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ /usr/include/strings.h \ @@ -49,14 +49,13 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ /usr/include/x86_64-linux-gnu/bits/stdlib.h m4ri/mzd.h m4ri/config.h \ m4ri/m4ri_config.h /usr/include/assert.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -64,110 +63,203 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h m4ri/misc.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h m4ri/misc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/mzp.h m4ri/xor.h m4ri/xor_template.h m4ri/graycode.h \ m4ri/echelonform.h m4ri/ple_russian.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/brilliantrussian.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/string.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + m4ri/misc.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/mzp.h: + m4ri/xor.h: + m4ri/xor_template.h: + m4ri/graycode.h: + m4ri/echelonform.h: + m4ri/ple_russian.h: diff --git a/m4ri-20140914/m4ri/.deps/debug_dump.Plo b/m4ri-20140914/m4ri/.deps/debug_dump.Plo index 6cbec4c..976f57e 100644 --- a/m4ri-20140914/m4ri/.deps/debug_dump.Plo +++ b/m4ri-20140914/m4ri/.deps/debug_dump.Plo @@ -1,14 +1,13 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \ m4ri/config.h m4ri/mzd.h m4ri/m4ri_config.h /usr/include/assert.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -19,9 +18,10 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -29,13 +29,13 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -58,7 +58,6 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -70,97 +69,185 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/mzp.h m4ri/mzd.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/mzd.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + m4ri/config.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/mzp.h: + m4ri/mzd.h: diff --git a/m4ri-20140914/m4ri/.deps/djb.Plo b/m4ri-20140914/m4ri/.deps/djb.Plo index 07959b5..a0ed60b 100644 --- a/m4ri-20140914/m4ri/.deps/djb.Plo +++ b/m4ri-20140914/m4ri/.deps/djb.Plo @@ -1,14 +1,13 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -19,9 +18,10 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -29,13 +29,13 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -58,7 +58,6 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -70,7 +69,7 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/io.h m4ri/djb.h m4ri/xor.h m4ri/xor_template.h \ @@ -81,103 +80,201 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ /usr/include/x86_64-linux-gnu/bits/unistd.h \ /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/io.h: + m4ri/djb.h: + m4ri/xor.h: + m4ri/xor_template.h: + /usr/include/unistd.h: + /usr/include/x86_64-linux-gnu/bits/posix_opt.h: + /usr/include/x86_64-linux-gnu/bits/environments.h: + /usr/include/x86_64-linux-gnu/bits/confname.h: + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h: + /usr/include/x86_64-linux-gnu/bits/getopt_core.h: + /usr/include/x86_64-linux-gnu/bits/unistd.h: + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h: diff --git a/m4ri-20140914/m4ri/.deps/echelonform.Plo b/m4ri-20140914/m4ri/.deps/echelonform.Plo index d3a9544..ef40082 100644 --- a/m4ri-20140914/m4ri/.deps/echelonform.Plo +++ b/m4ri-20140914/m4ri/.deps/echelonform.Plo @@ -1,15 +1,14 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \ m4ri/config.h m4ri/echelonform.h m4ri/mzd.h m4ri/config.h \ m4ri/m4ri_config.h /usr/include/assert.h /usr/include/features.h \ - /usr/include/features-time64.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,9 +19,10 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,100 +70,191 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/brilliantrussian.h m4ri/mzp.h m4ri/ple.h m4ri/triangular.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/echelonform.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/brilliantrussian.h: + m4ri/mzp.h: + m4ri/ple.h: + m4ri/triangular.h: diff --git a/m4ri-20140914/m4ri/.deps/graycode.Plo b/m4ri-20140914/m4ri/.deps/graycode.Plo index ed48650..0c1e631 100644 --- a/m4ri-20140914/m4ri/.deps/graycode.Plo +++ b/m4ri-20140914/m4ri/.deps/graycode.Plo @@ -1,16 +1,15 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \ m4ri/config.h /usr/include/stdio.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ @@ -20,14 +19,14 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/misc.h \ - m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ @@ -48,7 +47,6 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -60,81 +58,152 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/graycode.h + /usr/include/stdc-predef.h: + m4ri/config.h: + /usr/include/stdio.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/floatn.h: -/usr/include/x86_64-linux-gnu/bits/floatn-common.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: + m4ri/misc.h: + m4ri/m4ri_config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + /usr/include/assert.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/graycode.h: diff --git a/m4ri-20140914/m4ri/.deps/io.Plo b/m4ri-20140914/m4ri/.deps/io.Plo index 5814d92..bd57205 100644 --- a/m4ri-20140914/m4ri/.deps/io.Plo +++ b/m4ri-20140914/m4ri/.deps/io.Plo @@ -1,15 +1,14 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \ m4ri/m4ri_config.h m4ri/io.h m4ri/m4ri_config.h m4ri/mzd.h m4ri/config.h \ /usr/include/assert.h /usr/include/features.h \ - /usr/include/features-time64.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,9 +19,10 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,98 +70,187 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/echelonform.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/m4ri_config.h: + m4ri/io.h: + m4ri/m4ri_config.h: + m4ri/mzd.h: + m4ri/config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/echelonform.h: diff --git a/m4ri-20140914/m4ri/.deps/misc.Plo b/m4ri-20140914/m4ri/.deps/misc.Plo index bc79e18..4abc849 100644 --- a/m4ri-20140914/m4ri/.deps/misc.Plo +++ b/m4ri-20140914/m4ri/.deps/misc.Plo @@ -1,16 +1,15 @@ m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/stdio.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ @@ -20,13 +19,13 @@ m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h /usr/include/stdlib.h \ /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ @@ -47,96 +46,168 @@ m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ /usr/include/x86_64-linux-gnu/bits/stdlib.h m4ri/graycode.h m4ri/misc.h \ - m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/assert.h /usr/include/string.h \ /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/mmc.h m4ri/misc.h + /usr/include/stdc-predef.h: + m4ri/config.h: + /usr/include/stdio.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/floatn.h: -/usr/include/x86_64-linux-gnu/bits/floatn-common.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/graycode.h: + m4ri/misc.h: + m4ri/m4ri_config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/assert.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/mmc.h: + m4ri/misc.h: diff --git a/m4ri-20140914/m4ri/.deps/mmc.Plo b/m4ri-20140914/m4ri/.deps/mmc.Plo index dc9452d..35163cd 100644 --- a/m4ri-20140914/m4ri/.deps/mmc.Plo +++ b/m4ri-20140914/m4ri/.deps/mmc.Plo @@ -1,22 +1,21 @@ m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \ m4ri/mmc.h m4ri/misc.h m4ri/m4ri_config.h m4ri/config.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/bits/floatn.h \ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ @@ -38,7 +37,6 @@ m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -50,70 +48,130 @@ m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/mmc.h: + m4ri/misc.h: + m4ri/m4ri_config.h: + m4ri/config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + /usr/include/assert.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: diff --git a/m4ri-20140914/m4ri/.deps/mp.Plo b/m4ri-20140914/m4ri/.deps/mp.Plo index 34d24c4..4e27411 100644 --- a/m4ri-20140914/m4ri/.deps/mp.Plo +++ b/m4ri-20140914/m4ri/.deps/mp.Plo @@ -1,22 +1,21 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \ m4ri/misc.h m4ri/m4ri_config.h m4ri/config.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/bits/floatn.h \ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ @@ -38,7 +37,6 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -50,7 +48,7 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/mp.h m4ri/mzd.h \ m4ri/config.h /usr/include/math.h \ @@ -60,8 +58,9 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -69,106 +68,199 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h m4ri/misc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h m4ri/misc.h \ m4ri/debug_dump.h m4ri/brilliantrussian.h m4ri/mzp.h m4ri/strassen.h \ m4ri/brilliantrussian.h + /usr/include/stdc-predef.h: + m4ri/m4ri_config.h: + m4ri/misc.h: + m4ri/m4ri_config.h: + m4ri/config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + /usr/include/assert.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/mp.h: + m4ri/mzd.h: + m4ri/config.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + m4ri/misc.h: + m4ri/debug_dump.h: + m4ri/brilliantrussian.h: + m4ri/mzp.h: + m4ri/strassen.h: + m4ri/brilliantrussian.h: diff --git a/m4ri-20140914/m4ri/.deps/mzd.Plo b/m4ri-20140914/m4ri/.deps/mzd.Plo index c6204d6..93b5747 100644 --- a/m4ri-20140914/m4ri/.deps/mzd.Plo +++ b/m4ri-20140914/m4ri/.deps/mzd.Plo @@ -1,20 +1,19 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/stdlib.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/bits/floatn.h \ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ @@ -36,7 +35,6 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -54,8 +52,9 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -63,104 +62,192 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h m4ri/misc.h \ - m4ri/config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h m4ri/misc.h \ + m4ri/config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h \ /usr/include/stdint.h /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/parity.h m4ri/mmc.h + /usr/include/stdc-predef.h: + m4ri/config.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: + m4ri/mzd.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + m4ri/misc.h: + m4ri/config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/parity.h: + m4ri/mmc.h: diff --git a/m4ri-20140914/m4ri/.deps/mzp.Plo b/m4ri-20140914/m4ri/.deps/mzp.Plo index 2f708e9..d25d397 100644 --- a/m4ri-20140914/m4ri/.deps/mzp.Plo +++ b/m4ri-20140914/m4ri/.deps/mzp.Plo @@ -1,15 +1,14 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \ m4ri/mzp.h m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h \ /usr/include/assert.h /usr/include/features.h \ - /usr/include/features-time64.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,9 +19,10 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,97 +70,185 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/mzd.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/mzp.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/mzd.h: diff --git a/m4ri-20140914/m4ri/.deps/ple.Plo b/m4ri-20140914/m4ri/.deps/ple.Plo index d944b81..1d76f3b 100644 --- a/m4ri-20140914/m4ri/.deps/ple.Plo +++ b/m4ri-20140914/m4ri/.deps/ple.Plo @@ -1,16 +1,15 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/stdio.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ @@ -20,23 +19,24 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/mzd.h \ m4ri/m4ri_config.h /usr/include/assert.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,104 +70,198 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/triangular.h m4ri/mzd.h m4ri/parity.h m4ri/ple_russian.h m4ri/mzp.h \ m4ri/strassen.h m4ri/brilliantrussian.h m4ri/ple.h + /usr/include/stdc-predef.h: + m4ri/config.h: + /usr/include/stdio.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/floatn.h: -/usr/include/x86_64-linux-gnu/bits/floatn-common.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: + m4ri/mzd.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + m4ri/config.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/triangular.h: + m4ri/mzd.h: + m4ri/parity.h: + m4ri/ple_russian.h: + m4ri/mzp.h: + m4ri/strassen.h: + m4ri/brilliantrussian.h: + m4ri/ple.h: diff --git a/m4ri-20140914/m4ri/.deps/ple_russian.Plo b/m4ri-20140914/m4ri/.deps/ple_russian.Plo index 5ebd020..80e7a06 100644 --- a/m4ri-20140914/m4ri/.deps/ple_russian.Plo +++ b/m4ri-20140914/m4ri/.deps/ple_russian.Plo @@ -1,25 +1,24 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \ m4ri/config.h m4ri/m4ri_config.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/bits/floatn.h \ /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ @@ -41,7 +40,6 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -54,8 +52,9 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -63,7 +62,7 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/misc.h \ /usr/include/string.h \ @@ -72,104 +71,198 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/mzp.h m4ri/brilliantrussian.h m4ri/graycode.h m4ri/xor.h \ m4ri/xor_template.h m4ri/ple_russian_template.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/m4ri_config.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/ple_russian.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/mzp.h: + m4ri/brilliantrussian.h: + m4ri/graycode.h: + m4ri/xor.h: + m4ri/xor_template.h: + m4ri/ple_russian_template.h: diff --git a/m4ri-20140914/m4ri/.deps/solve.Plo b/m4ri-20140914/m4ri/.deps/solve.Plo index 4ef5621..620ae58 100644 --- a/m4ri-20140914/m4ri/.deps/solve.Plo +++ b/m4ri-20140914/m4ri/.deps/solve.Plo @@ -1,15 +1,14 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \ m4ri/solve.h m4ri/mzp.h m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h \ /usr/include/assert.h /usr/include/features.h \ - /usr/include/features-time64.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,9 +19,10 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,103 +70,196 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/strassen.h m4ri/brilliantrussian.h m4ri/ple.h m4ri/triangular.h \ m4ri/mzp.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/solve.h: + m4ri/mzp.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/strassen.h: + m4ri/brilliantrussian.h: + m4ri/ple.h: + m4ri/triangular.h: + m4ri/mzp.h: diff --git a/m4ri-20140914/m4ri/.deps/strassen.Plo b/m4ri-20140914/m4ri/.deps/strassen.Plo index 23a65ea..66ce024 100644 --- a/m4ri-20140914/m4ri/.deps/strassen.Plo +++ b/m4ri-20140914/m4ri/.deps/strassen.Plo @@ -1,14 +1,13 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \ m4ri/config.h m4ri/graycode.h m4ri/strassen.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -19,10 +18,11 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h m4ri/mzd.h m4ri/config.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h m4ri/mzd.h m4ri/config.h \ m4ri/m4ri_config.h /usr/include/assert.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,100 +70,191 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/brilliantrussian.h m4ri/mzp.h m4ri/parity.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/graycode.h: + m4ri/strassen.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/brilliantrussian.h: + m4ri/mzp.h: + m4ri/parity.h: diff --git a/m4ri-20140914/m4ri/.deps/triangular.Plo b/m4ri-20140914/m4ri/.deps/triangular.Plo index a4dc5d8..8dcf694 100644 --- a/m4ri-20140914/m4ri/.deps/triangular.Plo +++ b/m4ri-20140914/m4ri/.deps/triangular.Plo @@ -1,16 +1,15 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \ m4ri/config.h /usr/include/stdio.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ @@ -20,23 +19,24 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/triangular.h m4ri/mzd.h \ m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \ /usr/include/math.h /usr/include/x86_64-linux-gnu/bits/math-vector.h \ /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,103 +70,196 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/triangular_russian.h m4ri/strassen.h m4ri/brilliantrussian.h \ m4ri/mzp.h m4ri/mzd.h m4ri/parity.h + /usr/include/stdc-predef.h: + m4ri/config.h: + /usr/include/stdio.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/floatn.h: -/usr/include/x86_64-linux-gnu/bits/floatn-common.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: + m4ri/triangular.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/triangular_russian.h: + m4ri/strassen.h: + m4ri/brilliantrussian.h: + m4ri/mzp.h: + m4ri/mzd.h: + m4ri/parity.h: diff --git a/m4ri-20140914/m4ri/.deps/triangular_russian.Plo b/m4ri-20140914/m4ri/.deps/triangular_russian.Plo index 41b92dc..ca8517d 100644 --- a/m4ri-20140914/m4ri/.deps/triangular_russian.Plo +++ b/m4ri-20140914/m4ri/.deps/triangular_russian.Plo @@ -1,15 +1,14 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \ /usr/include/stdc-predef.h m4ri/config.h m4ri/triangular_russian.h \ m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \ - /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ /usr/include/x86_64-linux-gnu/bits/long-double.h \ /usr/include/x86_64-linux-gnu/gnu/stubs.h \ /usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \ /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ /usr/include/x86_64-linux-gnu/bits/typesizes.h \ /usr/include/x86_64-linux-gnu/bits/time64.h \ /usr/include/x86_64-linux-gnu/bits/math-vector.h \ @@ -20,9 +19,10 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \ /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ - /usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ @@ -30,13 +30,13 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \ /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \ + /usr/include/x86_64-linux-gnu/bits/sys_errlist.h \ /usr/include/x86_64-linux-gnu/bits/stdio.h \ /usr/include/x86_64-linux-gnu/bits/stdio2.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \ /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ /usr/include/x86_64-linux-gnu/sys/types.h \ @@ -59,7 +59,6 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \ @@ -71,103 +70,196 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \ /usr/include/strings.h \ /usr/include/x86_64-linux-gnu/bits/strings_fortified.h \ /usr/include/x86_64-linux-gnu/bits/string_fortified.h \ - /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \ /usr/include/x86_64-linux-gnu/bits/wchar.h \ /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \ m4ri/graycode.h m4ri/brilliantrussian.h m4ri/mzp.h m4ri/ple_russian.h \ m4ri/xor.h m4ri/xor_template.h + /usr/include/stdc-predef.h: + m4ri/config.h: + m4ri/triangular_russian.h: + m4ri/mzd.h: + m4ri/config.h: + m4ri/m4ri_config.h: + /usr/include/assert.h: + /usr/include/features.h: -/usr/include/features-time64.h: -/usr/include/x86_64-linux-gnu/bits/wordsize.h: -/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + /usr/include/x86_64-linux-gnu/bits/long-double.h: + /usr/include/x86_64-linux-gnu/gnu/stubs.h: + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + /usr/include/math.h: + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + /usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + /usr/include/x86_64-linux-gnu/bits/typesizes.h: + /usr/include/x86_64-linux-gnu/bits/time64.h: + /usr/include/x86_64-linux-gnu/bits/math-vector.h: + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + /usr/include/x86_64-linux-gnu/bits/floatn.h: + /usr/include/x86_64-linux-gnu/bits/floatn-common.h: + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + /usr/include/x86_64-linux-gnu/bits/fp-logb.h: + /usr/include/x86_64-linux-gnu/bits/fp-fast.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + /usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/mathinline.h: + /usr/include/stdio.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/FILE.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h: -/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h: + +/usr/include/x86_64-linux-gnu/bits/sys_errlist.h: + /usr/include/x86_64-linux-gnu/bits/stdio.h: + /usr/include/x86_64-linux-gnu/bits/stdio2.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h: + /usr/include/stdlib.h: + /usr/include/x86_64-linux-gnu/bits/waitflags.h: + /usr/include/x86_64-linux-gnu/bits/waitstatus.h: + /usr/include/x86_64-linux-gnu/sys/types.h: + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + /usr/include/x86_64-linux-gnu/bits/types/time_t.h: + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + /usr/include/endian.h: + /usr/include/x86_64-linux-gnu/bits/endian.h: + /usr/include/x86_64-linux-gnu/bits/endianness.h: + /usr/include/x86_64-linux-gnu/bits/byteswap.h: + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + /usr/include/x86_64-linux-gnu/sys/select.h: + /usr/include/x86_64-linux-gnu/bits/select.h: + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + /usr/include/x86_64-linux-gnu/bits/select2.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: -/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + /usr/include/alloca.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h: + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + /usr/include/x86_64-linux-gnu/bits/stdlib.h: + m4ri/misc.h: + /usr/include/string.h: + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + /usr/include/strings.h: + /usr/include/x86_64-linux-gnu/bits/strings_fortified.h: + /usr/include/x86_64-linux-gnu/bits/string_fortified.h: -/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h: + +/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h: + /usr/include/stdint.h: + /usr/include/x86_64-linux-gnu/bits/wchar.h: + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + m4ri/debug_dump.h: + m4ri/graycode.h: + m4ri/brilliantrussian.h: + m4ri/mzp.h: + m4ri/ple_russian.h: + m4ri/xor.h: + m4ri/xor_template.h: diff --git a/m4ri-20140914/m4ri/.libs/brilliantrussian.o b/m4ri-20140914/m4ri/.libs/brilliantrussian.o index ab0a4c7..c9df264 100644 Binary files a/m4ri-20140914/m4ri/.libs/brilliantrussian.o and b/m4ri-20140914/m4ri/.libs/brilliantrussian.o differ diff --git a/m4ri-20140914/m4ri/.libs/debug_dump.o b/m4ri-20140914/m4ri/.libs/debug_dump.o index 331721a..142636a 100644 Binary files a/m4ri-20140914/m4ri/.libs/debug_dump.o and b/m4ri-20140914/m4ri/.libs/debug_dump.o differ diff --git a/m4ri-20140914/m4ri/.libs/djb.o b/m4ri-20140914/m4ri/.libs/djb.o index 74e79fd..dde7271 100644 Binary files a/m4ri-20140914/m4ri/.libs/djb.o and b/m4ri-20140914/m4ri/.libs/djb.o differ diff --git a/m4ri-20140914/m4ri/.libs/echelonform.o b/m4ri-20140914/m4ri/.libs/echelonform.o index fbedbfe..3524340 100644 Binary files a/m4ri-20140914/m4ri/.libs/echelonform.o and b/m4ri-20140914/m4ri/.libs/echelonform.o differ diff --git a/m4ri-20140914/m4ri/.libs/graycode.o b/m4ri-20140914/m4ri/.libs/graycode.o index ce962cf..ef1c35a 100644 Binary files a/m4ri-20140914/m4ri/.libs/graycode.o and b/m4ri-20140914/m4ri/.libs/graycode.o differ diff --git a/m4ri-20140914/m4ri/.libs/io.o b/m4ri-20140914/m4ri/.libs/io.o index 8f3c05e..372e3cf 100644 Binary files a/m4ri-20140914/m4ri/.libs/io.o and b/m4ri-20140914/m4ri/.libs/io.o differ diff --git a/m4ri-20140914/m4ri/.libs/misc.o b/m4ri-20140914/m4ri/.libs/misc.o index e247c72..20033c2 100644 Binary files a/m4ri-20140914/m4ri/.libs/misc.o and b/m4ri-20140914/m4ri/.libs/misc.o differ diff --git a/m4ri-20140914/m4ri/.libs/mmc.o b/m4ri-20140914/m4ri/.libs/mmc.o index e8587e1..145ea30 100644 Binary files a/m4ri-20140914/m4ri/.libs/mmc.o and b/m4ri-20140914/m4ri/.libs/mmc.o differ diff --git a/m4ri-20140914/m4ri/.libs/mp.o b/m4ri-20140914/m4ri/.libs/mp.o index 68ccf5b..4b33e54 100644 Binary files a/m4ri-20140914/m4ri/.libs/mp.o and b/m4ri-20140914/m4ri/.libs/mp.o differ diff --git a/m4ri-20140914/m4ri/.libs/mzd.o b/m4ri-20140914/m4ri/.libs/mzd.o index bc09a1a..7784b96 100644 Binary files a/m4ri-20140914/m4ri/.libs/mzd.o and b/m4ri-20140914/m4ri/.libs/mzd.o differ diff --git a/m4ri-20140914/m4ri/.libs/mzp.o b/m4ri-20140914/m4ri/.libs/mzp.o index ba84e0d..c692e6c 100644 Binary files a/m4ri-20140914/m4ri/.libs/mzp.o and b/m4ri-20140914/m4ri/.libs/mzp.o differ diff --git a/m4ri-20140914/m4ri/.libs/ple.o b/m4ri-20140914/m4ri/.libs/ple.o index 9c668cb..68eecc9 100644 Binary files a/m4ri-20140914/m4ri/.libs/ple.o and b/m4ri-20140914/m4ri/.libs/ple.o differ diff --git a/m4ri-20140914/m4ri/.libs/ple_russian.o b/m4ri-20140914/m4ri/.libs/ple_russian.o index 170b630..a1ed50f 100644 Binary files a/m4ri-20140914/m4ri/.libs/ple_russian.o and b/m4ri-20140914/m4ri/.libs/ple_russian.o differ diff --git a/m4ri-20140914/m4ri/.libs/solve.o b/m4ri-20140914/m4ri/.libs/solve.o index 2491fac..3099c8a 100644 Binary files a/m4ri-20140914/m4ri/.libs/solve.o and b/m4ri-20140914/m4ri/.libs/solve.o differ diff --git a/m4ri-20140914/m4ri/.libs/strassen.o b/m4ri-20140914/m4ri/.libs/strassen.o index 91a615f..c8a15ba 100644 Binary files a/m4ri-20140914/m4ri/.libs/strassen.o and b/m4ri-20140914/m4ri/.libs/strassen.o differ diff --git a/m4ri-20140914/m4ri/.libs/triangular.o b/m4ri-20140914/m4ri/.libs/triangular.o index 3d4a99b..66623f9 100644 Binary files a/m4ri-20140914/m4ri/.libs/triangular.o and b/m4ri-20140914/m4ri/.libs/triangular.o differ diff --git a/m4ri-20140914/m4ri/.libs/triangular_russian.o b/m4ri-20140914/m4ri/.libs/triangular_russian.o index 7803bb5..aa912ed 100644 Binary files a/m4ri-20140914/m4ri/.libs/triangular_russian.o and b/m4ri-20140914/m4ri/.libs/triangular_russian.o differ diff --git a/m4ri-20140914/m4ri/brilliantrussian.o b/m4ri-20140914/m4ri/brilliantrussian.o index 70c5680..1033df6 100644 Binary files a/m4ri-20140914/m4ri/brilliantrussian.o and b/m4ri-20140914/m4ri/brilliantrussian.o differ diff --git a/m4ri-20140914/m4ri/debug_dump.o b/m4ri-20140914/m4ri/debug_dump.o index c663348..212a09e 100644 Binary files a/m4ri-20140914/m4ri/debug_dump.o and b/m4ri-20140914/m4ri/debug_dump.o differ diff --git a/m4ri-20140914/m4ri/djb.o b/m4ri-20140914/m4ri/djb.o index 6e60980..240fd09 100644 Binary files a/m4ri-20140914/m4ri/djb.o and b/m4ri-20140914/m4ri/djb.o differ diff --git a/m4ri-20140914/m4ri/echelonform.o b/m4ri-20140914/m4ri/echelonform.o index 652816f..5badf81 100644 Binary files a/m4ri-20140914/m4ri/echelonform.o and b/m4ri-20140914/m4ri/echelonform.o differ diff --git a/m4ri-20140914/m4ri/graycode.o b/m4ri-20140914/m4ri/graycode.o index ea83e37..164fe64 100644 Binary files a/m4ri-20140914/m4ri/graycode.o and b/m4ri-20140914/m4ri/graycode.o differ diff --git a/m4ri-20140914/m4ri/io.o b/m4ri-20140914/m4ri/io.o index 91e2010..2b7c8a1 100644 Binary files a/m4ri-20140914/m4ri/io.o and b/m4ri-20140914/m4ri/io.o differ diff --git a/m4ri-20140914/m4ri/m4ri_config.h b/m4ri-20140914/m4ri/m4ri_config.h index 0913aae..fcf5f1f 100644 --- a/m4ri-20140914/m4ri/m4ri_config.h +++ b/m4ri-20140914/m4ri/m4ri_config.h @@ -7,8 +7,8 @@ #define __M4RI_HAVE_SSE2 1 #define __M4RI_HAVE_OPENMP 0 #define __M4RI_CPU_L1_CACHE 32768 -#define __M4RI_CPU_L2_CACHE 1310720 -#define __M4RI_CPU_L3_CACHE 12582912 +#define __M4RI_CPU_L2_CACHE 524288 +#define __M4RI_CPU_L3_CACHE 33554432 #define __M4RI_DEBUG_DUMP (0 || 0) #define __M4RI_DEBUG_MZD 0 #define __M4RI_HAVE_LIBPNG 0 diff --git a/m4ri-20140914/m4ri/misc.o b/m4ri-20140914/m4ri/misc.o index 2816b8d..f59d942 100644 Binary files a/m4ri-20140914/m4ri/misc.o and b/m4ri-20140914/m4ri/misc.o differ diff --git a/m4ri-20140914/m4ri/mmc.o b/m4ri-20140914/m4ri/mmc.o index 04a47ad..1f52e38 100644 Binary files a/m4ri-20140914/m4ri/mmc.o and b/m4ri-20140914/m4ri/mmc.o differ diff --git a/m4ri-20140914/m4ri/mp.o b/m4ri-20140914/m4ri/mp.o index 6e48ca4..7e3d285 100644 Binary files a/m4ri-20140914/m4ri/mp.o and b/m4ri-20140914/m4ri/mp.o differ diff --git a/m4ri-20140914/m4ri/mzd.o b/m4ri-20140914/m4ri/mzd.o index d268298..c83b642 100644 Binary files a/m4ri-20140914/m4ri/mzd.o and b/m4ri-20140914/m4ri/mzd.o differ diff --git a/m4ri-20140914/m4ri/mzp.o b/m4ri-20140914/m4ri/mzp.o index 7bd9941..a780afc 100644 Binary files a/m4ri-20140914/m4ri/mzp.o and b/m4ri-20140914/m4ri/mzp.o differ diff --git a/m4ri-20140914/m4ri/ple.o b/m4ri-20140914/m4ri/ple.o index 95d8cbd..2e618a1 100644 Binary files a/m4ri-20140914/m4ri/ple.o and b/m4ri-20140914/m4ri/ple.o differ diff --git a/m4ri-20140914/m4ri/ple_russian.o b/m4ri-20140914/m4ri/ple_russian.o index 9e382d7..a41e6fa 100644 Binary files a/m4ri-20140914/m4ri/ple_russian.o and b/m4ri-20140914/m4ri/ple_russian.o differ diff --git a/m4ri-20140914/m4ri/solve.o b/m4ri-20140914/m4ri/solve.o index 014213d..8774693 100644 Binary files a/m4ri-20140914/m4ri/solve.o and b/m4ri-20140914/m4ri/solve.o differ diff --git a/m4ri-20140914/m4ri/strassen.o b/m4ri-20140914/m4ri/strassen.o index 5200615..f7ad1d3 100644 Binary files a/m4ri-20140914/m4ri/strassen.o and b/m4ri-20140914/m4ri/strassen.o differ diff --git a/m4ri-20140914/m4ri/triangular.o b/m4ri-20140914/m4ri/triangular.o index 7ef3306..41b2bec 100644 Binary files a/m4ri-20140914/m4ri/triangular.o and b/m4ri-20140914/m4ri/triangular.o differ diff --git a/m4ri-20140914/m4ri/triangular_russian.o b/m4ri-20140914/m4ri/triangular_russian.o index 6e0dcb0..e783969 100644 Binary files a/m4ri-20140914/m4ri/triangular_russian.o and b/m4ri-20140914/m4ri/triangular_russian.o differ diff --git a/makefile b/makefile index f438f11..5e13b26 100644 --- a/makefile +++ b/makefile @@ -9,6 +9,7 @@ CXX := mpicxx CXXFLAGS := -std=c++17 -O3 -Wall -Wextra -MMD -MP -march=native -mtune=native -g LIBS := -Wl,-Bstatic -lkissat -L kissat-inc/build -I kissat-inc/ \ + -llstech -L lstech_maple/build/release/lib -I lstech_maple/lstech/ \ -lm4ri -L m4ri-20140914/.libs -I m4ri-20140914/ \ -pthread -lz -lm -lboost_thread -lboost_date_time -lboost_system \ -Wl,-Bdynamic -lmpi_cxx -lmpi diff --git a/run.sh b/run.sh index 95c5a45..8171648 100755 --- a/run.sh +++ b/run.sh @@ -1,11 +1,11 @@ #!/bin/bash -cd kissat-inc -make clean -./configure -make -j 64 -cd .. -make clean +# cd kissat-inc +# make clean +# ./configure +# make -j 64 +# cd .. +# make clean # buglist # - fe96b630b3e761821308b544368dd521-GP_100_950_34.cnf @@ -18,6 +18,6 @@ INSTANCE=30ca21da9753263cc8cda020802b58ce-GP_500_200_20.cnf # make -j 16 && mpirun --bind-to none -np 9 --allow-run-as-root ./light -i $DIR/$INSTANCE --shuffle=1 --share=1 --threads=16 --times=3600 --share_method=1 -make -j 16 && mpirun --bind-to none -np 9 --allow-run-as-root ./light -i data/class_1_easy_10_0.cnf --share=1 --threads=16 --times=3600 --share_method=0 +make -j 16 && mpirun --bind-to none -np 9 --allow-run-as-root ./light -i data/hard1.cnf --share=1 --threads=16 --times=3600 --share_method=0 #./light -i $DIR/$INSTANCE --share=1 --threads=16 --times=3600 diff --git a/src/light.hpp b/src/light.hpp index 7ddcabd..3b597e3 100644 --- a/src/light.hpp +++ b/src/light.hpp @@ -20,9 +20,6 @@ class sharer; extern std::atomic terminated; extern std::mutex mtx; - -enum Solver_Type { KISSAT }; - struct thread_inf{ int id, inf; bool operator < ( const thread_inf &other ) const @@ -38,7 +35,6 @@ public: ~light(); // paras *opt; preprocess *pre; - vec solver_type; vec workers; vec sharers; pthread_t *sharer_ptrs; @@ -46,6 +42,7 @@ public: sharer* s; std::vector> sharing_groups; + enum { KISSAT, LSTECH } solver_type; enum { SAT, UNSAT, DEFAULT } worker_type; int worker_rs; diff --git a/src/sharer.cpp b/src/sharer.cpp index de6d4c5..b08b1bc 100644 --- a/src/sharer.cpp +++ b/src/sharer.cpp @@ -76,12 +76,14 @@ void sharer::share_clauses_to_other_node(int from, const std::vectorworker_type, send_length); MPI_Request *send_request = new MPI_Request(); // 环形传递 MPI_Isend(send_buf.get(), send_length, MPI_INT, next_node, SHARE_CLAUSES_TAG, MPI_COMM_WORLD, send_request); send_data_struct.push_back(std::make_pair(send_request, send_buf)); } - + // printf("c [worker] send clauses: %d\n", send_length); // 清理 send_data_struct，把发送完毕的发送数据结构清理掉 @@ -227,13 +229,13 @@ void sharer::do_clause_sharing() { cls.resize(t_size); + int percent = sort_clauses(i); //分享当前节点产生的子句 if(cls.size() > 0) share_clauses_to_other_node(rank, cls); //printf("c [worker] thread-%d: get %d exported clauses\n", i, t_size); // 增加 lits 限制 - int percent = sort_clauses(i); if(S->worker_type != light::SAT) { if (percent < 75) { diff --git a/src/solve.cpp b/src/solve.cpp index 327410b..c8bf8dd 100644 --- a/src/solve.cpp +++ b/src/solve.cpp @@ -1,5 +1,6 @@ #include "light.hpp" #include "solver_api/basekissat.hpp" +#include "solver_api/baselstech.hpp" #include "sharer.hpp" #include "paras.hpp" #include @@ -16,11 +17,7 @@ int result = 0; int winner_conf; void * read_worker(void *arg) { - basesolver * sq = (basesolver *)arg; -// if (worker_sign == "") -// sq->parse_from_PAR(sq->controller->pre); -// else -// sq->parse_from_CNF(worker_sign); + basesolver * sq = (basesolver *)arg; sq->parse_from_MEM(sq->controller->instance); return NULL; } @@ -48,112 +45,110 @@ void * solve_worker(void *arg) { void light::init_workers() { terminated = 0; for (int i = 0; i < OPT(threads); i++) { - basekissat* kissat = new basekissat(i, this); - workers.push(kissat); + if (solver_type == KISSAT) { + basekissat* kissat = new basekissat(i, this); + workers.push(kissat); + } + else if (solver_type == LSTECH) { + baselstech* lstech = new baselstech(i, this); + workers.push(lstech); + } } } void light::diversity_workers() { - + printf("c num %d\n", num_procs); for (int i = 0; i < OPT(threads); i++) { if(worker_type == SAT) { - if (OPT(shuffle)) { workers[i]->configure("worker_index", i); workers[i]->configure("worker_number", OPT(threads)); - if(rank == 1 || rank == num_procs - 1) { + if(rank == 1) { workers[i]->configure("worker_seed", 0); } else { workers[i]->configure("worker_seed", rank); } - // printf("r1: %d, r2: %d, r3: %d\n", r1, r2, r3); } + if (solver_type == KISSAT) { + workers[i]->configure("stable", 1); + workers[i]->configure("target", 2); + workers[i]->configure("phase", 1); - workers[i]->configure("stable", 1); - workers[i]->configure("target", 2); - workers[i]->configure("phase", 1); - // workers[i]->configure("heuristic", 0); + if (i == 2) + workers[i]->configure("stable", 0); + else if (i == 6) + workers[i]->configure("stable", 2); - if (i == 2) - workers[i]->configure("stable", 0); - else if (i == 6) - workers[i]->configure("stable", 2); - - if (i == 7) - workers[i]->configure("target", 0); - else if (i == 0 || i == 2 || i == 3 || i == 6) - workers[i]->configure("target", 1); - - if (i == 3 || i == 11 || i == 12 || i == 13 || i == 15) - workers[i]->configure("phase", 0); + if (i == 7) + workers[i]->configure("target", 0); + else if (i == 0 || i == 2 || i == 3 || i == 6) + workers[i]->configure("target", 1); + + if (i == 3 || i == 11 || i == 12 || i == 13 || i == 15) + workers[i]->configure("phase", 0); + } + } else if(worker_type == UNSAT) { OPT(share_lits) = 3000; workers[i]->configure("chrono", 1); workers[i]->configure("stable", 0); - // workers[i]->configure("walkinitially", 0); workers[i]->configure("target", 1); - - // workers[i]->configure("phase", 1); - // workers[i]->configure("heuristic", 0); - // workers[i]->configure("margin", 1)0; - - if (i == 0 || i == 1 || i == 7 || i == 8 || i == 11 || i == 15) - // workers[i]->configure("heuristic", 1); - - if (i == 3 || i == 6 || i == 8 || i == 11 || i == 12 || i == 13) - workers[i]->configure("chrono", 0); - - if (i == 2) - workers[i]->configure("stable", 1); - - if (i == 9) - workers[i]->configure("target", 0); - else if (i == 14) - workers[i]->configure("target", 2); - + if (solver_type == KISSAT) { + if (i == 0 || i == 1 || i == 7 || i == 8 || i == 11 || i == 15) + if (i == 3 || i == 6 || i == 8 || i == 11 || i == 12 || i == 13) + workers[i]->configure("chrono", 0); + if (i == 2) + workers[i]->configure("stable", 1); + if (i == 9) + workers[i]->configure("target", 0); + else if (i == 14) + workers[i]->configure("target", 2); + } } else { - if (OPT(shuffle)) { workers[i]->configure("worker_index", i); workers[i]->configure("worker_number", OPT(threads)); - workers[i]->configure("worker_seed", rank); - // printf("r1: %d, r2: %d, r3: %d\n", r1, r2, r3); + if(rank == num_procs - 1) { + workers[i]->configure("worker_seed", 0); + } else { + workers[i]->configure("worker_seed", rank); + } } - - if (i == 13 || i == 14 || i == 9) - workers[i]->configure("tier1", 3); - else - workers[i]->configure("tier1", 2); + if (solver_type == KISSAT) { + if (i == 13 || i == 14 || i == 9) + workers[i]->configure("tier1", 3); + else + workers[i]->configure("tier1", 2); + if (i == 3 || i == 6 || i == 8 || i == 11 || i == 12 || i == 13 || i == 14 || i == 15) + workers[i]->configure("chrono", 0); + else + workers[i]->configure("chrono", 1); - if (i == 3 || i == 6 || i == 8 || i == 11 || i == 12 || i == 13 || i == 14 || i == 15) - workers[i]->configure("chrono", 0); - else - workers[i]->configure("chrono", 1); + if (i == 2 || i == 15) + workers[i]->configure("stable", 0); + else if (i == 6 || i == 14) + workers[i]->configure("stable", 2); + else + workers[i]->configure("stable", 1); - if (i == 2 || i == 15) - workers[i]->configure("stable", 0); - else if (i == 6 || i == 14) - workers[i]->configure("stable", 2); - else - workers[i]->configure("stable", 1); + if (i == 10) + workers[i]->configure("walkinitially", 1); + else + workers[i]->configure("walkinitially", 0); - if (i == 10) - workers[i]->configure("walkinitially", 1); - else - workers[i]->configure("walkinitially", 0); - - if (i == 7 || i == 8 || i == 9 || i == 11) - workers[i]->configure("target", 0); - else if (i == 0 || i == 2 || i == 3 || i == 4 || i == 5 || i == 6 || i == 10) - workers[i]->configure("target", 1); - else - workers[i]->configure("target", 2); - - if (i == 4 || i == 5 || i == 8 || i == 9 || i == 12 || i == 13 || i == 15) - workers[i]->configure("phase", 0); - else - workers[i]->configure("phase", 1); + if (i == 7 || i == 8 || i == 9 || i == 11) + workers[i]->configure("target", 0); + else if (i == 0 || i == 2 || i == 3 || i == 4 || i == 5 || i == 6 || i == 10) + workers[i]->configure("target", 1); + else + workers[i]->configure("target", 2); + + if (i == 4 || i == 5 || i == 8 || i == 9 || i == 12 || i == 13 || i == 15) + workers[i]->configure("phase", 0); + else + workers[i]->configure("phase", 1); + } } } } @@ -260,11 +255,12 @@ int light::run() { } void light::seperate_groups() { + solver_type = light::LSTECH; // split distribute nodes to groups(SAT MODE、UNSAT MODE、DEFAULT MODE) int worker_procs = num_procs - 1; if(worker_procs >= 8) { - int sat_procs = worker_procs / 8; + int sat_procs = worker_procs / 4; int unsat_procs = worker_procs / 4; int default_procs = worker_procs - sat_procs - unsat_procs; diff --git a/src/solver_api/baselstech.cpp b/src/solver_api/baselstech.cpp new file mode 100755 index 0000000..3126b3e --- /dev/null +++ b/src/solver_api/baselstech.cpp @@ -0,0 +1,106 @@ +#include "utils/System.h" +#include "core/Dimacs.h" +#include "simp/SimpSolver.h" + +#include "baselstech.hpp" + +// using namespace Minisat; + +// Macros for minisat literal representation conversion +#define MINI_LIT(lit) lit > 0 ? Minisat::mkLit(lit - 1, false) : Minisat::mkLit((-lit) - 1, true) + +#define INT_LIT(lit) sign(lit) ? -(var(lit) + 1) : (var(lit) + 1) + +void baselstech::add(int l) { + puts("wrong"); +} + +int baselstech::configure(const char* name, int val) { + if (strcmp(name, "worker_index") == 0) solver->worker_index = val; + if (strcmp(name, "worker_seed") == 0) solver->worker_seed = val; + if (strcmp(name, "worker_number") == 0) solver->worker_number = val; + return 1; +} + +int baselstech::solve() { + Minisat::vec miniAssumptions; + Minisat::lbool res = solver->solveLimited(miniAssumptions); + if (res == (Minisat::lbool((uint8_t)0))) return 10; + if (res == (Minisat::lbool((uint8_t)1))) return 20; + return 0; +} + +int baselstech::val(int l) { + if (solver->model[l] != (Minisat::lbool((uint8_t)2))) { + int lit = solver->model[l] == (Minisat::lbool((uint8_t)0)) ? l + 1 : -(l + 1); + return lit; + } + return l; +} + +void baselstech::terminate() { + solver->interrupt(); +} + +void cbkLstechExportClause(void * issuer, int lbd, Minisat::vec &cls) { + baselstech* mp = (baselstech*)issuer; + if (lbd > mp->good_clause_lbd) return; + + shared_ptr ncls = std::make_shared(cls.size()); + for (int i = 0; i < cls.size(); i++) { + ncls->data[i] = INT_LIT(cls[i]); + } + + ncls->lbd = lbd; + mp->export_clause.push(ncls); +} + +bool cbkLstechImportClause(void * issuer, int * lbd, Minisat::vec & mcls) { + baselstech* mp = (baselstech*)issuer; + shared_ptr cls = NULL; + if (mp->import_clause.pop(cls) == false) return false; + *lbd = cls->lbd; + mcls.clear(); + for (size_t i = 0; i < cls->size; i++) { + Minisat::Lit lit = MINI_LIT(cls->data[i]); + mcls.push(lit); + } + cls->free_clause(); + return true; +} + +baselstech::baselstech(int id, light* light) : basesolver(id, light) { + printf("c id is %d\n", id); + solver = new Minisat::SimpSolver(); + solver->issuer = this; + solver->cbkExportClause = NULL; + solver->cbkImportClause = NULL; + if (OPT(share)) { + solver->cbkExportClause = cbkLstechExportClause; + solver->cbkImportClause = cbkLstechImportClause; + } +} + +baselstech::~baselstech() +{ + delete solver; +} + +void baselstech::parse_from_MEM(char* instance) { + int vars, clauses; + vec> clause; + readinstance(instance, &vars, &clauses, clause); + maxvar = vars; + solver->varGrowTo(vars); + Minisat::vec lits; + for (int i = 1; i <= clauses; i++) { + int l = clause[i].size(); + lits.clear(); + for (int j = 0; j < l; j++) + lits.push(MINI_LIT(clause[i][j])); + solver->addClause_(lits); + } +} +int baselstech::get_conflicts() { + return 0; +} \ No newline at end of file diff --git a/src/solver_api/baselstech.hpp b/src/solver_api/baselstech.hpp new file mode 100755 index 0000000..c98a03b --- /dev/null +++ b/src/solver_api/baselstech.hpp @@ -0,0 +1,33 @@ +#include "basesolver.hpp" + +namespace Minisat +{ + class SimpSolver; + class Lit; + template class vec; +} + +class baselstech : public basesolver { +public: + void terminate(); + void add(int l); + int solve(); + int val(int l); + int configure(const char* name, int id); + + int get_conflicts(); + void parse_from_MEM(char* instance); + void exp_clause(void *cl, int lbd) { + puts("wrong"); + } + bool imp_clause(shared_ptrcls, void *cl) { + puts("wrong"); + } + + baselstech(int id, light *light); + ~baselstech(); + + Minisat::SimpSolver* solver; + friend bool cbkLstechImportClause(void *, int *, Minisat::vec &); + friend void cbkLstechExportClause(void *, int, Minisat::vec &); +};