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