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