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