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