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