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