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