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