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