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