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