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