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