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