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