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