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