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