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