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