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