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