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