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