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