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