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