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