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