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