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